<!DOCTYPE html><html lang="zh-CN" data-theme="light"><head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no"><title>深度学习调优指南中文版 | kiloGrand</title><meta name="keywords" content="kiloGrand"><meta name="author" content="kiloGrand"><meta name="copyright" content="kiloGrand"><meta name="format-detection" content="telephone=no"><meta name="theme-color" content="#ffffff"><meta name="description" content="深度学习调优指南中文版这不是官方认证的 Google 产品。 Varun Godbole † , George E. Dahl † , Justin Gilmer † , Christopher J. Shallue ‡ , Zachary Nado † † 谷歌研究，谷歌大脑团队 ‡ 哈佛大学 目录 这份手册是为谁准备的？ 为什么需要这份调优手册？ 开始新项目的指南 选择模型架构 选择优化器 选">
<meta property="og:type" content="article">
<meta property="og:title" content="深度学习调优指南中文版">
<meta property="og:url" content="https://kilogrand.gitee.io/2023/02/26/tuning_playbook-zh_cn/index.html">
<meta property="og:site_name" content="kiloGrand">
<meta property="og:description" content="深度学习调优指南中文版这不是官方认证的 Google 产品。 Varun Godbole † , George E. Dahl † , Justin Gilmer † , Christopher J. Shallue ‡ , Zachary Nado † † 谷歌研究，谷歌大脑团队 ‡ 哈佛大学 目录 这份手册是为谁准备的？ 为什么需要这份调优手册？ 开始新项目的指南 选择模型架构 选择优化器 选">
<meta property="og:locale" content="zh_CN">
<meta property="og:image" content="https://kilogrand.gitee.io/img/coding.jpg">
<meta property="article:published_time" content="2023-02-26T01:41:10.000Z">
<meta property="article:modified_time" content="2023-03-17T13:26:47.239Z">
<meta property="article:author" content="kiloGrand">
<meta property="article:tag" content="kiloGrand">
<meta name="twitter:card" content="summary">
<meta name="twitter:image" content="https://kilogrand.gitee.io/img/coding.jpg"><link rel="shortcut icon" href="/img/favicon.png"><link rel="canonical" href="https://kilogrand.gitee.io/2023/02/26/tuning_playbook-zh_cn/"><link rel="preconnect" href="//cdn.jsdelivr.net"/><link rel="preconnect" href="//busuanzi.ibruce.info"/><link rel="stylesheet" href="/css/index.css"><link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@fortawesome/fontawesome-free@6/css/all.min.css" media="print" onload="this.media='all'"><link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@fancyapps/ui/dist/fancybox.css" media="print" onload="this.media='all'"><script>const GLOBAL_CONFIG = { 
  root: '/',
  algolia: undefined,
  localSearch: {"path":"/search.xml","preload":false,"languages":{"hits_empty":"找不到您查询的内容：${query}"}},
  translate: undefined,
  noticeOutdate: undefined,
  highlight: {"plugin":"highlighjs","highlightCopy":true,"highlightLang":true,"highlightHeightLimit":false},
  copy: {
    success: '复制成功',
    error: '复制错误',
    noSupport: '浏览器不支持'
  },
  relativeDate: {
    homepage: false,
    post: false
  },
  runtime: '',
  date_suffix: {
    just: '刚刚',
    min: '分钟前',
    hour: '小时前',
    day: '天前',
    month: '个月前'
  },
  copyright: undefined,
  lightbox: 'fancybox',
  Snackbar: undefined,
  source: {
    justifiedGallery: {
      js: 'https://cdn.jsdelivr.net/npm/flickr-justified-gallery@2/dist/fjGallery.min.js',
      css: 'https://cdn.jsdelivr.net/npm/flickr-justified-gallery@2/dist/fjGallery.min.css'
    }
  },
  isPhotoFigcaption: false,
  islazyload: false,
  isAnchor: true
}</script><script id="config-diff">var GLOBAL_CONFIG_SITE = {
  title: '深度学习调优指南中文版',
  isPost: true,
  isHome: false,
  isHighlightShrink: false,
  isToc: true,
  postUpdate: '2023-03-17 21:26:47'
}</script><noscript><style type="text/css">
  #nav {
    opacity: 1
  }
  .justified-gallery img {
    opacity: 1
  }

  #recent-posts time,
  #post-meta time {
    display: inline !important
  }
</style></noscript><script>(win=>{
    win.saveToLocal = {
      set: function setWithExpiry(key, value, ttl) {
        if (ttl === 0) return
        const now = new Date()
        const expiryDay = ttl * 86400000
        const item = {
          value: value,
          expiry: now.getTime() + expiryDay,
        }
        localStorage.setItem(key, JSON.stringify(item))
      },

      get: function getWithExpiry(key) {
        const itemStr = localStorage.getItem(key)

        if (!itemStr) {
          return undefined
        }
        const item = JSON.parse(itemStr)
        const now = new Date()

        if (now.getTime() > item.expiry) {
          localStorage.removeItem(key)
          return undefined
        }
        return item.value
      }
    }
  
    win.getScript = url => new Promise((resolve, reject) => {
      const script = document.createElement('script')
      script.src = url
      script.async = true
      script.onerror = reject
      script.onload = script.onreadystatechange = function() {
        const loadState = this.readyState
        if (loadState && loadState !== 'loaded' && loadState !== 'complete') return
        script.onload = script.onreadystatechange = null
        resolve()
      }
      document.head.appendChild(script)
    })
  
      win.activateDarkMode = function () {
        document.documentElement.setAttribute('data-theme', 'dark')
        if (document.querySelector('meta[name="theme-color"]') !== null) {
          document.querySelector('meta[name="theme-color"]').setAttribute('content', '#0d0d0d')
        }
      }
      win.activateLightMode = function () {
        document.documentElement.setAttribute('data-theme', 'light')
        if (document.querySelector('meta[name="theme-color"]') !== null) {
          document.querySelector('meta[name="theme-color"]').setAttribute('content', '#ffffff')
        }
      }
      const t = saveToLocal.get('theme')
    
          if (t === 'dark') activateDarkMode()
          else if (t === 'light') activateLightMode()
        
    const detectApple = () => {
      if(/iPad|iPhone|iPod|Macintosh/.test(navigator.userAgent)){
        document.documentElement.classList.add('apple')
      }
    }
    detectApple()
    })(window)</script><meta name="generator" content="Hexo 5.4.2"></head><body><div id="sidebar"><div id="menu-mask"></div><div id="sidebar-menus"><div class="avatar-img is-center"><img src="/img/profile.png" onerror="onerror=null;src='/img/friend_404.gif'" alt="avatar"/></div><div class="sidebar-site-data site-data is-center"><a href="/archives/"><div class="headline">文章</div><div class="length-num">46</div></a><a href="/tags/"><div class="headline">标签</div><div class="length-num">6</div></a><a href="/categories/"><div class="headline">分类</div><div class="length-num">5</div></a></div><hr/><div class="menus_items"><div class="menus_item"><a class="site-page" href="/"><i class="fa-fw fas fa-home"></i><span> 主页</span></a></div><div class="menus_item"><a class="site-page" href="/archives/"><i class="fa-fw fas fa-archive"></i><span> 归档</span></a></div><div class="menus_item"><a class="site-page" href="/tags/"><i class="fa-fw fas fa-tags"></i><span> 标签</span></a></div><div class="menus_item"><a class="site-page" href="/categories/"><i class="fa-fw fas fa-folder-open"></i><span> 分类</span></a></div><div class="menus_item"><a class="site-page" href="/link/"><i class="fa-fw fas fa-link"></i><span> Link</span></a></div></div></div></div><div class="post" id="body-wrap"><header class="post-bg" id="page-header" style="background-image: url('/img/coding.jpg')"><nav id="nav"><span id="blog_name"><a id="site-name" href="/">kiloGrand</a></span><div id="menus"><div id="search-button"><a class="site-page social-icon search"><i class="fas fa-search fa-fw"></i><span> 搜索</span></a></div><div class="menus_items"><div class="menus_item"><a class="site-page" href="/"><i class="fa-fw fas fa-home"></i><span> 主页</span></a></div><div class="menus_item"><a class="site-page" href="/archives/"><i class="fa-fw fas fa-archive"></i><span> 归档</span></a></div><div class="menus_item"><a class="site-page" href="/tags/"><i class="fa-fw fas fa-tags"></i><span> 标签</span></a></div><div class="menus_item"><a class="site-page" href="/categories/"><i class="fa-fw fas fa-folder-open"></i><span> 分类</span></a></div><div class="menus_item"><a class="site-page" href="/link/"><i class="fa-fw fas fa-link"></i><span> Link</span></a></div></div><div id="toggle-menu"><a class="site-page"><i class="fas fa-bars fa-fw"></i></a></div></div></nav><div id="post-info"><h1 class="post-title">深度学习调优指南中文版</h1><div id="post-meta"><div class="meta-firstline"><span class="post-meta-date"><i class="far fa-calendar-alt fa-fw post-meta-icon"></i><span class="post-meta-label">发表于</span><time class="post-meta-date-created" datetime="2023-02-26T01:41:10.000Z" title="发表于 2023-02-26 09:41:10">2023-02-26</time><span class="post-meta-separator">|</span><i class="fas fa-history fa-fw post-meta-icon"></i><span class="post-meta-label">更新于</span><time class="post-meta-date-updated" datetime="2023-03-17T13:26:47.239Z" title="更新于 2023-03-17 21:26:47">2023-03-17</time></span><span class="post-meta-categories"><span class="post-meta-separator">|</span><i class="fas fa-inbox fa-fw post-meta-icon"></i><a class="post-meta-categories" href="/categories/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/">深度学习</a></span></div><div class="meta-secondline"><span class="post-meta-separator">|</span><span class="post-meta-wordcount"><i class="far fa-file-word fa-fw post-meta-icon"></i><span class="post-meta-label">字数总计:</span><span class="word-count">25.6k</span><span class="post-meta-separator">|</span><i class="far fa-clock fa-fw post-meta-icon"></i><span class="post-meta-label">阅读时长:</span><span>76分钟</span></span><span class="post-meta-separator">|</span><span class="post-meta-pv-cv" id="" data-flag-title="深度学习调优指南中文版"><i class="far fa-eye fa-fw post-meta-icon"></i><span class="post-meta-label">阅读量:</span><span id="busuanzi_value_page_pv"></span></span></div></div></div></header><main class="layout" id="content-inner"><div id="post"><article class="post-content" id="article-container"><h1 id="深度学习调优指南中文版"><a href="#深度学习调优指南中文版" class="headerlink" title="深度学习调优指南中文版"></a>深度学习调优指南中文版</h1><p><em>这不是官方认证的 Google 产品。</em></p>
<p><strong>Varun Godbole † , George E. Dahl † , Justin Gilmer † , Christopher J. Shallue ‡ , Zachary Nado †</strong></p>
<p>† 谷歌研究，谷歌大脑团队</p>
<p>‡ 哈佛大学</p>
<h2 id="目录"><a href="#目录" class="headerlink" title="目录"></a>目录</h2><ul>
<li><a href="#这份手册是为谁准备的">这份手册是为谁准备的？</a></li>
<li><a href="#为什么需要这份调优手册">为什么需要这份调优手册？</a></li>
<li><a href="#开始新项目的指南">开始新项目的指南</a><ul>
<li><a href="#选择模型架构">选择模型架构</a></li>
<li><a href="#选择优化器">选择优化器</a></li>
<li><a href="#选择Batchsize">选择BatchSize</a></li>
<li><a href="#选择初始配置">选择初始配置</a></li>
</ul>
</li>
<li><a href="#提高模型性能的科学方法">提高模型性能的科学方法</a><ul>
<li><a href="#增量调整策略">增量调整策略</a></li>
<li><a href="#探索与利用">探索与利用</a></li>
<li><a href="#选择下一轮实验的目标">选择下一轮实验的目标</a></li>
<li><a href="#设计下一轮实验">设计下一轮实验</a></li>
<li><a href="#确定是否采用此训练工作流更改或超参数配置">确定是否采用此训练工作流更改或超参数配置</a></li>
<li><a href="#探索结束后">探索结束后</a></li>
</ul>
</li>
<li><a href="#确定每次训练运行的步数">确定每次训练运行的步数</a><ul>
<li><a href="#当训练不受计算限制时如何决定该训练多久">当训练不受计算限制时如何决定该训练多久</a></li>
<li><a href="#当训练受计算限制时如何决定该训练多久">当训练受计算限制时如何决定该训练多久</a></li>
</ul>
</li>
<li><a href="#关于训练工作流的额外补充">关于训练工作流的额外补充</a><ul>
<li><a href="#优化输入管道">优化输入管道</a></li>
<li><a href="#评估模型性能">评估模型性能</a></li>
<li><a href="#保存检查点并追溯选择最佳检查点">保存检查点并追溯选择最佳检查点</a></li>
<li><a href="#设置实验跟踪">设置实验跟踪</a></li>
<li><a href="#batchnorm的实现细节">BatchNorm的实现细节</a></li>
<li><a href="#多主机工作流的注意事项">多主机工作流的注意事项</a></li>
</ul>
</li>
<li><a href="#常见问题的回答">常见问题的回答</a></li>
<li><a href="#致谢">致谢</a></li>
<li><a href="#引用">引用</a></li>
<li><a href="#关于贡献">关于贡献</a></li>
</ul>
<h2 id="这份手册是为谁准备的？"><a href="#这份手册是为谁准备的？" class="headerlink" title="这份手册是为谁准备的？"></a>这份手册是为谁准备的？</h2><p><strong>本文档适用于对最大化深度学习的性能</strong>感兴趣的工程师和研究人员（包括个人和团队）。我们假定您具备机器学习和深度学习概念的基本知识。</p>
<p>我们的重点是<strong>超参数调优的过程</strong>，但我们还涉及深度学习学习的其他方面。例如工作流实施和优化，但这些方面并不详尽</p>
<p>我们假设机器学习问题是监督学习或类似的东西（例如自监督学习）。但是，本文档中描述的技术也可能适用于其他类型的问题。</p>
<h2 id="为什么需要这份调优手册？"><a href="#为什么需要这份调优手册？" class="headerlink" title="为什么需要这份调优手册？"></a>为什么需要这份调优手册？</h2><p>目前，要使深度神经网络在实践中正常运行，需要付出大量的努力和猜测。更糟糕的是，目前很少有人记录下那些深度学习中获得良好结果的实际方法。一方面，通常，论文忽略了导致最终结果的过程，以呈现更清晰的原理。另一方面，处理商业问题的机器学习工程师很少有时间回顾并概括他们的调参过程。教科书也往往回避实用指南，而偏重于基本原理，即使它们的作者具有在应用工作中提供有用建议的经验。在准备创建此文档时，我们找不到任何系统性的资料来解释<em>如何使用深度学习获得良好的结果</em>. 相反，我们看到了博客文章和社交媒体上的建议片段、从研究论文附录中收集的技巧、特定项目或工作流的偶然案例研究，以及很多困惑。在深度学习领域，专家和新手用着表面上类似的方法，但所取得的结果之间存在着巨大的差距。与此同时，这些专家也很乐意承认他们所做的一些事情可能没有充分的理由。随着深度学习的成熟并对世界产生更大的影响，社区需要更多涵盖有用方法的资源，包括对于获得良好结果至关重要的所有实用细节。</p>
<p>我们是一个由五名研究人员和工程师组成的团队，多年来一直致力于深度学习。我们已经将深度学习应用到从语音识别到天文学的方方面面，并在此过程中学到了很多东西。本文档源于我们自己训练神经网络、教授学生以及为我们的同事提供实践建议的经验。虽然深度学习已经从少数学术研究实验室中实践的机器学习方法发展成为为数十亿人使用的产品提供动力的技术，但深度学习在工程领域仍处于起步阶段，我们希望本文档能鼓励其他人也来帮助系统化该领域的实验细节。</p>
<p>这份文件是在我们试图实现我们自己的深度学习方法时产生的，因此它只代表作者在撰写本文时的观点，而不是任何客观事实。它被特别强调是因为我们在调整超参数方面遇到了困难，但它也涵盖了我们在工作中遇到（或看到出错）的其他重要问题。我们希望这项工作成为一份活的文件，能随着我们理解的改变从而成长和演变。例如，一份关于如何调试和如何减少训练失败的文档在两年前是不可能写出来的，因为它这得基于最近的结果和正在进行的研究。不可避免地，我们的在此文档中一些建议也将需要更新以考虑新的结果和改进的工作流程。我们不知道最好的深度学习秘诀，但在大众开始记录它并讨论各个步骤之前，我们不能指望找到它。为此，我们鼓励发现我们的建议存在问题的读者提出替代建议以及令人信服的证据，以便我们更新建议。我们也希望看到可能有不同建议的替代指南和方式，以帮助大众追求最佳方法。最后，任何标有🤖表情符号的地方是我们要进一步调查的地方。只有在尝试编写这本 playbook 之后，我们才完全清楚在深度学习从业者的工作流程中可以找到多少有趣及被忽视的研究问题。</p>
<h2 id="开始新项目的指南"><a href="#开始新项目的指南" class="headerlink" title="开始新项目的指南"></a>开始新项目的指南</h2><p>在调优过程中的许多抉择，我们可以在项目开始时一次性做出决定。只有偶尔在情况发生变化时，才需要重新考虑。</p>
<p>在开始调优之前，请确保您满足以下假设：</p>
<ul>
<li>问题制定、数据清理等基本工作已经完成，花时间在模型架构和训练配置上是有意义的。</li>
<li>已经有一个工作流设置用来进行训练和评估，并且可以很容易地为各种感兴趣的模型执行训练和预测工作。</li>
<li>已选择并实现适当的评估指标。这些指标应该尽可能地代表在部署环境中测量的内容。</li>
</ul>
<h3 id="选择模型架构"><a href="#选择模型架构" class="headerlink" title="选择模型架构"></a>选择模型架构</h3><p><strong><em>总结</em></strong>： <em>在开始一个新项目时，尽量重用有效的模型。</em></p>
<ul>
<li>首先选择一个完善且常用的模型架构来开始工作。这样可以尽早让模型进入工作状态，之后再构建自定义模型也是可行的。</li>
<li>模型架构通常具有各种超参数，用于确定模型的大小和其他细节（例如层数、层宽度、激活函数类型）。<ul>
<li>因此，选择架构实际上意味着选择一整个系列的各种模型（每个模型都有不同的超参数设置）。</li>
</ul>
</li>
<li>如果可以的话，请尝试找到一篇尽可能接近手头问题的相关论文，并将复现该论文中的模型作为起点。</li>
</ul>
<h3 id="选择优化器"><a href="#选择优化器" class="headerlink" title="选择优化器"></a>选择优化器</h3><p><strong><em>总结</em></strong>： <em>从针对手头问题类型的最常用的优化器开始。</em></p>
<ul>
<li><p>没有一个优化器是适用于所有类型的机器学习问题和模型架构的‘最佳’优化器。即使只是 <a target="_blank" rel="noopener" href="https://arxiv.org/abs/1910.05446">比较优化器的性能</a>也是一项艰巨的任务。 🤖</p>
</li>
<li><p>我们建议坚持使用成熟、流行的优化器，尤其是在开始新项目时。</p>
<ul>
<li>理想情况下，选择用于同类问题的最常用优化器。</li>
</ul>
</li>
<li><p>做好关注选择的优化器的 <b>*所有*</b> 超参数的准备。</p>
<ul>
<li><p>具有更多超参数的优化器可能需要更多的调优工作才能找到最佳配置。</p>
</li>
<li><p>当我们试图找到各种其他超参数（例如架构超参数）的最佳值时，将优化器超参数视为<a href="#identifying-scientific-nuisance-and-fixed-hyperparameters">冗余参数</a>是有意义的，这在项目的初始阶段尤其重要。</p>
</li>
<li>在项目的初始阶段，从更简单的优化器开始会更可取（例如，具有固定动量的 SGD 或具有固定 $\epsilon$、$\beta<em>{1}$ 和 $\beta</em>{2}$ 的 Adam ) ，之后可以切换到更通用的优化器。</li>
</ul>
</li>
<li><p>常用且较为完善的优化器包括（但不限于）：</p>
<ul>
<li><a href="#what-are-the-update-rules-for-all-the-popular-optimization-algorithms">SGD with momentum</a>（Nesterov 变体）</li>
<li><a href="#what-are-the-update-rules-for-all-the-popular-optimization-algorithms">Adam and NAdam</a>，它们比具有动量的 SGD 更通用。请注意，Adam 有 4 个可调超参数，<a target="_blank" rel="noopener" href="https://arxiv.org/abs/1910.05446">他们都很重要</a>！<ul>
<li>参见 <a href="#Adam 的超参数应该如何调整？">Adam 的超参数应该如何调整？</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<h3 id="选择BatchSize"><a href="#选择BatchSize" class="headerlink" title="选择BatchSize"></a>选择BatchSize</h3><p><strong><em>总结</em></strong>： <em>Batch Size决定训练速度，并且不应该被直接用于调整验证集性能。通常来说，可用硬件支持的最大Batch Size是较为理想的数值。</em></p>
<ul>
<li>Batch Size是决定<em>训练时间</em>和<em>计算资源消耗</em>的关键因素。</li>
<li>增加Batch Size通常会减少训练时间。这非常有益，因为它：<ul>
<li>能使固定时间间隔内超参数调整更彻底，最终训练出更好的模型。</li>
<li>减少开发周期的延迟，能更多地测试新想法。</li>
</ul>
</li>
<li>资源消耗和Batch Size之间并没有明确的关系，增加Batch Size让资源消耗增加、减少或是保持不变都有可能。</li>
<li>Batch Size<em>不应该</em>被当作验证集性能的可调超参数。<ul>
<li>只要调整好所有超参数（尤其是学习率和正则化超参数）并且训练步数足够，理论上任意的Batch Size都能获得相同的最终性能（参见 <a target="_blank" rel="noopener" href="https://arxiv.org/abs/1811.03600">Shallue et al. 2018</a>） .</li>
<li>详见 <a href="#为什么不应该调整Batch Size来直接提高验证集性能？">为什么不应该调整Batch Size来直接提高验证集性能？</a></li>
</ul>
</li>
</ul>
<h4 id="确定可行的Batch-Size并估计训练吞吐量"><a href="#确定可行的Batch-Size并估计训练吞吐量" class="headerlink" title="确定可行的Batch Size并估计训练吞吐量"></a>确定可行的Batch Size并估计训练吞吐量</h4><ul>
<li>对于给定的模型和优化器，可用硬件通常能能够支持一系列Batch Size。限制因素通常是加速器（GPU/TPU 等）的内存。</li>
<li>不幸的是，如果不运行或者编译完整的训练程序，就很难计算出适合内存的Batch Size。</li>
<li>最简单的解决方案通常是以不同的批次大小（例如，用 2 的幂来尝试）运行少量的训练实验，直到其中一个实验超过可用内存。</li>
<li>对于每个Batch Size，我们应该训练足够长的时间以准确估计<em>训练吞吐量</em></li>
</ul>
<p align="center">训练吞吐量 =每秒处理的样本数量</p>

<p align="center">或者，我们可以估计<em>每步时间</em> :</p>

<p align="center">每步时间 =（Batch Size）/（训练吞吐量）</p>

<ul>
<li>当加速器内存未饱和时，如果Batch Size加倍，训练吞吐量也应该加倍（或至少接近加倍）。等效地，随着Batch Size的增加，每步的时间应该是恒定的（或至少接近恒定的）。</li>
<li>如果与上述情况不符，那么训练工作流可能存在瓶颈，例如 I/O 或计算节点间的同步。有必要在开始下一步前对此进行诊断和矫正。</li>
<li>如果训练吞吐量到某个Batch Size之后就不再增加，那么我们只考虑使用该Batch Size（即使硬件支持更大的Batch Size）<ul>
<li>使用更大Batch Size的所有好处都假定训练吞吐量增加。如果没有，请修复瓶颈或使用较小的Batch Size。</li>
<li>使用<strong>梯度积累</strong>技术可以支持的更大的Batch Size。但其不提供任何训练吞吐量优势，故在应用工作中通常应避免使用它。</li>
</ul>
</li>
<li>每次更改模型或优化器时，可能都需要重复这些步骤（例如，不同的模型架构可能允许更大的Batch Size）。</li>
</ul>
<h4 id="选择合适的Batch-Size以最小化训练时间"><a href="#选择合适的Batch-Size以最小化训练时间" class="headerlink" title="选择合适的Batch Size以最小化训练时间"></a>选择合适的Batch Size以最小化训练时间</h4><p align="center">训练时间 =（每步时间）x（总步数）</p>

<ul>
<li>对于所有可行的Batch Size，我们通常可以认为每步的时间近似恒定(实际上，增加Batch Size通常会产生一些开销)。</li>
<li>Batch Size越大，达到某一性能目标所需的步数通常会减少（前提是在更改Batch Size时重新调整所有相关超参数；<a target="_blank" rel="noopener" href="https://arxiv.org/abs/1811.03600">Shallue et al. 2018</a>）。<ul>
<li>例如，将Batch Size翻倍可能会使训练步数减半。这称为<strong>完美缩放</strong>。</li>
<li>完美缩放适用于Batch Size在临界值之前，超过该临界总步数的减少效果将会下降。</li>
<li>最终，增加Batch Size不会再使训练步数减少（永远不会增加）。</li>
</ul>
</li>
<li>因此，最小化训练时间的Batch Size通常是最大的Batch Size，也同时减少了所需的训练步数。<ul>
<li>Batch Size取决于数据集、模型和优化器，除了通过实验为每个新问题找到它之外，如何计算它是一个悬而未决的问题。🤖</li>
<li>比较Batch Size时，请注意效果(epoch)预算（运行所有实验，固定训练样本的数量达到设定的效果所花的时间）和步数预算（运行设定步数的试验）之间的区别。<ul>
<li>将Batch Size与效果预算进行比较只会涉及到完美缩放的范围，即使更大的Batch Size仍可能通过减少所需的训练步数来提供有意义的加速。</li>
</ul>
</li>
<li>通常，可用硬件支持的最大Batch Size将小于临界Batch Size。因此，一个好的经验法则（不运行任何实验）是使用尽可能大的Batch Size。</li>
</ul>
</li>
<li>如果最终增加了训练时间，那么使用更大的Batch Size就没有意义了。</li>
</ul>
<h4 id="选择合适的Batch-Size以最小化资源消耗"><a href="#选择合适的Batch-Size以最小化资源消耗" class="headerlink" title="选择合适的Batch Size以最小化资源消耗"></a>选择合适的Batch Size以最小化资源消耗</h4><ul>
<li>有两种类型的资源成本与增加 batch size有关。<pre><code>1. 前期成本，例如购买新硬件或重写训练工作流以实现多GPU/多TPU训练。
1. 使用成本，例如，根据团队的资源预算计费，从云供应商处计费，电力/维护成本。
</code></pre></li>
</ul>
<p>如果增加 batch size有很大的前期成本，那么直到项目成熟且容易权衡成本效益前，推迟其的增加可能更好。实施多机并行训练程序可能会引入<a href="https://link.zhihu.com/?target=https%3A//github.com/google-research/tuning_playbook%23considerations-for-multi-host-pipelines">错误</a>和<a href="https://link.zhihu.com/?target=https%3A//github.com/google-research/tuning_playbook%23batch-normalization-implementation-details">一些棘手的细节</a>，所以无论如何，一开始最好是用一个比较简单的工作流。(另一方面，当需要进行大量的调优实验时，训练时间的大幅加速可能会在过程的早期非常有利）。</p>
<p>我们把总的使用成本（可能包括多种不同类型的成本）称为 “资源消耗 “。我们可以将资源消耗分解为以下几个部分。</p>
<p>资源消耗 = (每步的资源消耗) x (总步数)</p>
<ul>
<li><p>增加 batch size通常可以减少总步骤数。资源消耗是增加还是减少，将取决于每步的消耗如何变化。</p>
</li>
<li><ul>
<li>增加 batch size可能会减少资源消耗。例如，如果大batch size的每一步都可以在与小batch size相同的硬件上运行（每一步只增加少量时间），那么每一步资源消耗的增加可能被步骤数的减少所抵消。</li>
<li>增加 batch size可能不会改变资源消耗。例如，如果将batch size增加一倍，所需的步骤数减少一半，所使用的GPU数量增加一倍，总消耗量（以GPU小时计）将不会改变。</li>
<li>增加 batch size可能会增加资源消耗。例如，如果增加batch size需要升级硬件，那么每步消耗的增加可能超过训练所需步数的减少。</li>
</ul>
</li>
</ul>
<h4 id="更改Batch-Size需要重新调整大多数超参数"><a href="#更改Batch-Size需要重新调整大多数超参数" class="headerlink" title="更改Batch Size需要重新调整大多数超参数"></a>更改Batch Size需要重新调整大多数超参数</h4><ul>
<li>大多数超参数的最佳值对Batch Size敏感。因此，更改Batch Size通常需要重新开始调整过程。</li>
<li>与Batch Size交互最强烈的超参数是优化器超参数（学习率、动量等）和正则化超参数，所以有必要对于针对每个Batch Size单独调整它们。</li>
<li>在项目开始时选择Batch Size时请记住，如果您以后需要切换到不同的Batch Size，则为新的Batch Size重新调整所有内容可能会很困难、耗时且成本高昂。</li>
</ul>
<h4 id="Batch-Norm会对Batch-Size的选择造成什么影响？"><a href="#Batch-Norm会对Batch-Size的选择造成什么影响？" class="headerlink" title="Batch Norm会对Batch Size的选择造成什么影响？"></a>Batch Norm会对Batch Size的选择造成什么影响？</h4><p>Batch norm 很复杂，一般来说，应该使用与计算梯度不同的 batch size 来计算统计数据(像<a target="_blank" rel="noopener" href="https://arxiv.org/abs/1705.08741">Ghost Batch Norm</a>采用固定值的batch size)。有关详细讨论，请参阅<a href="#BatchNorm的实现细节">BatchNorm的实现细节</a></p>
<h4 id="选择初始配置"><a href="#选择初始配置" class="headerlink" title="选择初始配置"></a>选择初始配置</h4><ul>
<li>在开始超参数调整之前，我们必须确定起点。这包括指定 (1) 模型配置（例如层数），(2) 优化器超参数（例如学习率），以及 (3) 训练步数。</li>
<li>确定此初始配置将需要一些手动配置的训练运行和反复试验。</li>
<li>我们的指导原则是找到一个简单、相对快速、资源消耗相对较低的配置，以获得“合理”的结果。<ul>
<li>“简单”意味着尽可能避免花里胡哨的东西；这些总是可以在以后添加。即使花里胡哨的东西在未来被证明是有用的，但在初始配置中添加它们可能会浪费时间调整无用的功能和/或烘烤不必要的并发症。<ul>
<li>例如，在添加花哨的衰减方案之前以恒定的学习率开始。</li>
</ul>
</li>
<li>选择快速且消耗最少资源的初始配置将使超参数调整更加高效。<ul>
<li>例如，从较小的模型开始。</li>
</ul>
</li>
<li>“合理”性能取决于问题，但至少意味着经过训练的模型在验证集上的性能比随机机会好得多（尽管它可能很糟糕，不值得部署）。</li>
</ul>
</li>
<li>选择训练步数的数量涉及平衡以下方面：<ul>
<li>一方面，训练更多的步数可以提高性能并使超参数调整更容易（参见 <a target="_blank" rel="noopener" href="https://arxiv.org/abs/1811.03600">Shallue et al. 2018</a>）。</li>
<li>另一方面，更少步数的训练意味着每次训练运行得更快并且使用更少的资源，通过减少周期之间的时间并允许并行运行更多实验来提高调整效率。此外，如果一开始选择了一个不必要的大训练步数，那么以后可能很难改变它，例如，已经将学习率针对该步数进行了调整。</li>
</ul>
</li>
</ul>
<h2 id="提高模型性能的科学方法"><a href="#提高模型性能的科学方法" class="headerlink" title="提高模型性能的科学方法"></a>提高模型性能的科学方法</h2><p>机器学习开发的最终目标是最大化模型的效用。尽管不同应用场景的开发流程有所不同（例如时间长度、可用计算资源、模型类型等），基本步骤和原则都是相似的。</p>
<p>接下来的指南中我们做出了这些假设：</p>
<ul>
<li>已有能运行且得到不错结果的训练工作流。</li>
<li>有足够的计算资源来进行调参实验，至少能够并行发起数个训练流程。</li>
</ul>
<h3 id="增量调整策略"><a href="#增量调整策略" class="headerlink" title="增量调整策略"></a>增量调整策略</h3><p><strong><em>总结</em></strong>： <em>从简单的配置开始，循序渐进，同时进一步了解问题。确保任何改进都有据可循，以避免增加不必要的复杂度。</em></p>
<ul>
<li>我们的最终目标是找到一种训练配置来最大化我们模型的性能。<ul>
<li>在某些情况下，我们的目标是在固定截止日期（例如提交给竞赛）之前最大限度地改进模型。</li>
<li>在其他情况下，我们希望无限期地改进模型（例如，不断改进生产中使用的模型）。</li>
</ul>
</li>
<li>原则上，我们可以使用算法自动搜索整个配置空间来最大化性能，但实践中这往往不实际。<ul>
<li>配置空间可能非常大，目前还没有任何算法可以在没有人工指导的情况下有效地搜索这个空间。</li>
</ul>
</li>
<li>大多数自动搜索算法依赖于人工设计的<em>搜索空间</em>，这些搜索空间往往非常重要。</li>
<li>更有效的方法是从简单的配置开始，逐步添加功能并进行改进，同时深化对问题的理解。<ul>
<li>我们在每一轮调整中都使用自动搜索算法，并随着我们理解的深度不断更新我们的搜索空间。</li>
</ul>
</li>
<li>随着我们的探索，我们自然会找到越来越好的配置，因此我们的“最佳”模型将不断改进。<ul>
<li>当我们更新我们的最佳配置时，我们称之为<em>上线</em>（这不一定对应线上模型的实际上线）。</li>
<li>对于每次上线，我们必须确保更改是有据可循的——而不仅仅是碰运气找到的配置——以避免给训练工作流增加不必要的复杂性。</li>
</ul>
</li>
</ul>
<p>综上所述，我们的增量调优策略需要重复以下四个步骤：</p>
<ol>
<li>为下一轮实验确定适当的目标。</li>
<li>设计并展开实验，朝着这个目标取得进展。</li>
<li>从实验结果中获取经验。</li>
<li>考虑是否上线新的最佳配置。</li>
</ol>
<p>本节的其余部分将更详细地讲解增量调优策略。</p>
<h3 id="探索与利用"><a href="#探索与利用" class="headerlink" title="探索与利用"></a>探索与利用</h3><p><strong><em>总结</em></strong>： <em>大多数时候，我们的目标是更深入地理解问题。</em></p>
<ul>
<li>尽管有些人认为我们会花大部分时间来提升验证集的指标，实际上我们把重心放在进一步理解问题上，而不是降低验证集错误率。<ul>
<li>也就是说，我们大部分时间都花在了“探索”上，只有一小部分时间花在了“利用”上。</li>
</ul>
</li>
<li>从长远来看，如果我们想最大化我们的最终效果，深入理解问题是至关重要的。将深化理解置于短期收益之上可以帮助我们：<ul>
<li>避免仅因历史原因而表现良好的不必要更改。</li>
<li>确定验证集效果对哪些超参数最敏感，哪些超参数交互最多，因此需要一起重新调整，以及哪些超参数对其他变化相对不敏感，因此可以在未来的实验中固定住。</li>
<li>发现潜在的新方向，例如在出现过拟合问题时使用新的正则化器。</li>
<li>确定无效的方向并将其删除，从而降低后续实验的复杂度。</li>
<li>判断超参数的优化空间是否已经饱和。</li>
<li>围绕最佳值缩小我们的搜索空间，以提高调整效率。</li>
</ul>
</li>
<li>最终，我们可以集中提升验证集效果，即便我们无法从新的实验中进一步了解问题的结构了。</li>
</ul>
<h3 id="选择下一轮实验的目标"><a href="#选择下一轮实验的目标" class="headerlink" title="选择下一轮实验的目标"></a>选择下一轮实验的目标</h3><p><strong><em>总结</em></strong>： <em>每轮实验都应该有一个明确的目标，并且范围要足够小，这样实验才能真正朝着目标取得进展。</em></p>
<ul>
<li>每轮实验都应该有一个明确的目标，并且范围要足够小，这样实验才能真正朝着目标取得进展：如果我们试图一次添加多个特征或回答多个问题，我们可能无法理清各自的影响。</li>
<li>举个例子，目标可以包括：<ul>
<li>尝试对训练流程进行改进（例如，新的正则化器、预处理方法等）。</li>
<li>了解特定模型超参数（例如激活函数）的影响</li>
<li>最大化验证集指标。</li>
</ul>
</li>
</ul>
<h3 id="设计下一轮实验"><a href="#设计下一轮实验" class="headerlink" title="设计下一轮实验"></a>设计下一轮实验</h3><p><strong><em>总结</em></strong>： <em>根据实验目标，将超参数分为三类：目标超参数、冗余超参数和固定超参数。创建一系列研究以比较目标超参数的不同值，同时优化冗余超参数。注意选择冗余超参数的搜索空间，以平衡资源成本与科学价值。</em></p>
<h4 id="识别目标超参数、冗余超参数和固定超参数"><a href="#识别目标超参数、冗余超参数和固定超参数" class="headerlink" title="识别目标超参数、冗余超参数和固定超参数"></a>识别目标超参数、冗余超参数和固定超参数</h4><ul>
<li>对于给定的目标，所有超参数都将是<strong>目标超参数</strong>、<strong>冗余超参数</strong>或<strong>固定超参数</strong>。<ul>
<li>目标超参数是指，我们希望测量出其对于模型由何种影响的参数。</li>
<li>冗余超参数是指，必须优化才能公平比较不同目标超参数值的参数。类似于统计中的<a target="_blank" rel="noopener" href="https://en.wikipedia.org/wiki/Nuisance_parameter">冗余参数</a>。</li>
<li>固定超参数是指，在当前轮次实验中取固定值的参数。在比较目标超参数的不同值时，固定超参数的值不需要（或者我们不希望它们）改变。<ul>
<li>因为实验固定了某些超参数，从实验得出的结论可能对固定超参数的其他值无效。换句话说，固定的超参数对我们的实验结论做了限定。</li>
</ul>
</li>
</ul>
</li>
<li>举个例子，如果我们的目标是“确定更深的模型是否会减少验证集错误”，那么模型层数就是目标超参数。<ul>
<li>学习率是一个冗余超参数，如果我们要公平对比不同深度的模型，我们必须分别调整学习率（通常情况下最优学习率和模型结构有关）。</li>
<li>激活函数是一个固定超参数。我们可能通过过去的实验发现最优激活函数和模型深度无关。或者我们接受实验得到的最优深度的仅在某个激活函数上有效。或者我们也可以将激活函数作为一个冗余超参数和深度一起调优。</li>
</ul>
</li>
<li>一个超参数是目标超参数、冗余超参数还是固定超参数是根据实验目标来决定的。<ul>
<li>比如，激活函数的选择可以是一个目标超参数（对于当前问题，ReLU 或 tanh 是更好的选择吗？），一个冗余超参数（允许使用不同的激活函数，最好的 5 层模型是否优于最好的 6 层模型？），或一个固定超参数（对于一个由 ReLU 构成的网络，在特定位置添加批标准化是否有帮助？）。</li>
</ul>
</li>
<li>在设计新一轮实验时，我们根据实验目的确定目标超参数。<ul>
<li>在此阶段，我们将所有其他超参数视为冗余超参数。</li>
</ul>
</li>
<li>接下来，我们将一些冗余超参数转作为固定超参数。<ul>
<li>如果有无限的计算资源，我们会将所有非目标超参数保留为冗余超参数，这样我们从实验中得出的结论就不会受到固定超参数的限定。</li>
<li>然而，冗余超参数越多，我们没能充分针对每个目标超参数调优冗余超参数的风险就越高，从而我们从实验中得出错误结论的风险也越高。<ul>
<li>如<a href="#平衡实验的信息量和成本">下文</a>所述，我们可以通过增加计算资源来应对这种风险，但通常我们的最大资源预算低于调整所有非目标超参数所需的计算资源。</li>
</ul>
</li>
<li>当我们判断将一个冗余超参数转换为固定超参数所带来的限制少于调优它所需的计算资源时，我们可以进行这种转换。<ul>
<li>一个冗余超参数和目标超参数的相互影响越多，固定这个参数所带来的限制就越多。例如，权重衰减强度的最佳值通常取决于模型大小，因此固定权重衰减的强度来比较不同的模型大小，往往得不出有效的结论。</li>
</ul>
</li>
</ul>
</li>
<li>尽管超参数的类型取决于实验目标，但对于某些类别的超参数，我们有以下经验法则：<ul>
<li>在各种优化器超参数（例如学习率、动量、学习率调度参数、Adam优化器的beta等）中，至少有一些是冗余超参数，因为它们往往与其他变化相互影响。<ul>
<li>它们很少是目标超参数，因为像“训练流程的最佳学习率是多少？”这样的目标没有什么意义——最优学习率很容易随着下一次训练流程的改变而改变。</li>
<li>尽管当资源有限或有强力的证据表明它们不影响目标超参数时，我们可能固定其中一些参数，但通常应该假设优化器超参数必须单独调整，以在不同设置之间进行公平比较目标超参数。<ul>
<li>此外，我们没有优化器超参数值的<em>先验</em>倾向（例如，它们通常不会以任何方式影响前向传递或梯度的计算成本）。</li>
</ul>
</li>
</ul>
</li>
<li>相比之下，优化器的<em>选择</em>通常是一个目标超参数或固定超参数。<ul>
<li>如果我们的实验目标涉及在两个或多个不同的优化器之间进行公平比较（例如“确定哪个优化器在给定的步数中产生最低的验证错误”），那么它就是一个目标超参数。</li>
<li>或者，我们可能出于各种原因将其设为固定超参数，包括（1）先前的实验表明最好的优化器和当前的目标超参数无关；（2）当前优化器的训练曲线更容易理解 (3) 当前优化器比其他优化器使用更少的内存。</li>
</ul>
</li>
<li>正则化技术引入的超参数通常是冗余超参数，但是否使用正则化技术往往是目标或固定超参数。<ul>
<li>例如，dropout 增加了代码的复杂性，因此在决定是否包含它时，我们会将“no dropout”与“dropout”作为一个目标超参数，而将 dropout 率作为一个冗余超参数。<ul>
<li>如果我们决定根据这个实验将 dropout 添加到我们的训练流程中，那么在未来的实验中，dropout 率将是一个冗余超参数。</li>
</ul>
</li>
</ul>
</li>
<li>模型结构超参数通常是目标或固定超参数，因为模型结构变化会影响服务和训练成本、延迟和内存需求。<ul>
<li>例如，网络层数通常是一个目标或固定的超参数，因为它往往会对训练速度和内存使用产生巨大影响。</li>
</ul>
</li>
</ul>
</li>
<li>在某些情况下，一个超参数是冗余还是固定超参数将取决于目标超参数的值。<ul>
<li>例如，假设我们想知道 Nesterov momentum 和 Adam 中哪个优化器的验证错误率更低。目标超参数是 <code>optimizer</code>，它的值是 <code>&#123;&quot;Nesterov_momentum&quot;, &quot;Adam&quot;&#125;</code>。值 <code>optimizer=&quot;Nesterov_momentum&quot;</code> 引入了冗余/固定超参数 <code>&#123;learning_rate, momentum&#125;</code>，但值 <code>optimizer=&quot;Adam&quot;</code> 引入了冗余/固定超参数 <code>&#123;learning_rate, beta1, beta2, epsilon&#125;</code>。</li>
<li>仅针对目标超参数的某些值存在的超参数称为<strong>条件超参数</strong>。</li>
<li>我们不应该仅仅因为两个条件超参数具有相同的名称就认为它们是相同的！在上面的示例中， <code>learning_rate</code> 对于 <code>optimizer=&quot;Nesterov_momentum&quot;</code> 与 <code>optimizer=&quot;Adam&quot;</code> 是<em>不同的</em>条件超参数. 它在两种算法中的作用相似（尽管不完全相同），但在每个优化器中运行良好的值范围通常相差几个数量级。</li>
</ul>
</li>
</ul>
<h4 id="创建一组研究"><a href="#创建一组研究" class="headerlink" title="创建一组研究"></a>创建一组研究</h4><ul>
<li>确定了目标和冗余超参数之后，我们会设计一个“研究”或一系列研究，以朝着实验目标取得进展。<ul>
<li>一项研究指定了一组要运行的超参数配置以供后续分析。每个配置称为“试验”。</li>
<li>创建研究通常涉及几个方面：选择试验所需的超参数变量，选择这些超参数的取值范围（“搜索空间”），选择试验次数，以及选择自动搜索算法。或者，我们可以通过手动指定一组超参数配置来创建研究。</li>
</ul>
</li>
<li>研究的目的是使用目标超参数的不同值运行训练流程，同时 <strong>“优化掉”</strong>（或“优化”）冗余超参数，以便公平的比较不同的目标超参数值。</li>
<li>在最简单的情况下，我们将对目标超参数的每个配置进行单独研究，其中每个研究都会调整冗余超参数。<ul>
<li>例如，如果我们的目标是从 Nesterov、momentum 和 Adam 中选择最佳优化器，我们可以创建一个研究，并设置 <code>optimizer=&quot;Nesterov_momentum&quot;</code> 和冗余超参数为 <code>&#123;learning_rate, momentum&#125;</code>。然后创建另一项研究，并设置 <code>optimizer=&quot;Adam&quot;</code> 和冗余超参数为 <code>&#123;learning_rate, beta1, beta2, epsilon&#125;</code>。最后通过比较两个研究中的最优试验来比较这两个优化器。</li>
<li>我们可以使用任何无梯度优化算法，包括贝叶斯优化或进化算法等方法，来优化冗余超参数。但是，在<a href="#探索与利用">探索阶段</a>，<a href="#为什么在优化的探索阶段使用Quasi-Random-Search而不是更复杂的黑盒优化算法？">我们更偏向</a>使用准随机算法，因为这些方法在探索阶段有多种优势。在<a href="#探索结束后">探索结束后</a>，我们会优先选择最先进的贝叶斯优化方法。</li>
</ul>
</li>
<li>在更复杂的情况下，我们想要比较大量目标超参数的值，并且我们无法进行大量相对独立的研究，我们可以将目标超参数与冗余超参数放在相同的搜索空间中，并使用搜索算法在单个研究中对<em>两种超参数</em>的值进行采样。<ul>
<li>采用这种方法时，条件超参数可能会是一个问题，因为很难指定对应的搜索空间，除非所有目标超参数值都有相同的冗余超参数集。</li>
<li>在这种情况下，<a href="#为什么在优化的探索阶段使用Quasi-Random-Search而不是更复杂的黑盒优化算法？">我们更加偏好</a>使用Quasi-Random-Search算法，因为它确保我们能相对均匀的采样目标超参数值。无论搜索算法如何，我们都需要确保它均匀搜索目标超参数。</li>
</ul>
</li>
</ul>
<h4 id="平衡实验的信息量和成本"><a href="#平衡实验的信息量和成本" class="headerlink" title="平衡实验的信息量和成本"></a>平衡实验的信息量和成本</h4><ul>
<li>在设计一项研究或一系列研究时，我们需要分配有限的预算，以充分满足以下三个要求：<ol>
<li>比较足够多目标超参数的不同值。</li>
<li>在足够大的搜索空间上调整冗余超参数。</li>
<li>对冗余超参数的搜索空间进行足够密集的采样。</li>
</ol>
</li>
<li>这三个必要条件，确保我们能从实验中获得足够多的经验。<ul>
<li>尽可能多地比较目标超参数的值可以拓宽我们从实验中获得的经验的范围。</li>
<li>包括尽可能多的有冗余超参数，并允许每个冗余超参数有尽可能大的值域。这样我们更有信心相信，对于一个目标超参数配置，在当前搜索空间中，<strong>存在</strong>“好的”冗余参数。<ul>
<li>否则，我们可能因为没有搜索某些冗余超参数空间，而对不同目标超参数值进行了不公平的比较。</li>
</ul>
</li>
<li>尽可能密集地对冗余超参数采样，也能让我们更加有信心相信搜索流程能够找到好的冗余超参数配置。<ul>
<li>否则，我们可能对不同目标超参数值进行了不公平的比较。因为某些值恰好有更好的冗余超参数配置。</li>
</ul>
</li>
</ul>
</li>
<li>不幸的是，对这三个要求的<em>任何</em>一个进行改进都需要增加试验次数，从而增加资源成本。或者，我们只能从其他要求中想办法节约资源。<ul>
<li>每个问题都有自己的特性和计算资源限制，因此如何在这三个需求之间分配资源需要一定程度的领域专业知识。</li>
<li>在进行一项研究后，我们都会总结该研究是否将冗余超参数调整得足够好（即充分搜索了足够大的空间）以公平地比较目标超参数（更详细的描述<a href="#从实验结果中获取经验">如下</a>）。</li>
</ul>
</li>
</ul>
<h3 id="从实验结果中获取经验"><a href="#从实验结果中获取经验" class="headerlink" title="从实验结果中获取经验"></a>从实验结果中获取经验</h3><p><strong><em>总结</em></strong>： <em>除了尝试实现每组实验的原始科学目标之外，还要检查其他问题的清单，如果发现问题，请修改实验并重新运行。</em></p>
<ul>
<li>最终，每组实验都有一个特定的目标，我们想要评估实验为该目标提供的证据。<ul>
<li>然而，如果我们提出正确的问题，我们通常会发现在一组给定的实验能够朝着最初的目标取得很大进展之前需要纠正的问题。<ul>
<li>如果我们不问这些问题，我们可能会得出不正确的结论。</li>
</ul>
</li>
<li>由于运行实验的成本很高，我们还希望借此机会从每组实验中提取其他有用的见解，即使这些见解与当前目标并不直接相关。</li>
</ul>
</li>
<li>在分析一组给定的实验以朝着最初的目标取得进展之前，我们应该问自己以下额外的问题：<ul>
<li><a href="#identifying-bad-search-space-boundaries">搜索空间够大吗？</a><ul>
<li>如果研究的最佳点在一维或多维搜索空间的边界附近，则搜索可能不够广泛。在这种情况下，我们应该进行另一项具有扩展搜索空间的研究。</li>
</ul>
</li>
<li><a href="#not-sampling-enough-points-in-the-search-space">我们是否从搜索空间中采样了足够多的点？</a><ul>
<li>如果不是，则在调整目标中运行更多点或不那么雄心勃勃。</li>
</ul>
</li>
<li>每项研究中有多少试验是<strong>不可行</strong>（即出现分歧的试验、得到非常糟糕的损失值，或者因为违反某些隐式约束而根本无法运行）？<ul>
<li>当研究中很大一部分点是<strong>不可行</strong>时，我们应该尝试调整搜索空间以避免对这些点进行采样，这有时需要重新参数化搜索空间。</li>
<li>在某些情况下，大量不可行点可能表示训练代码中存在错误。</li>
</ul>
</li>
<li><a href="#how-can-optimization-failures-be-debugged-and-mitigated">模型是否存在优化问题？</a></li>
<li><a href="#examining-the-training-curves">我们可以从最佳试验的训练曲线中学到什么？</a><ul>
<li>例如，最好的试验是否具有与有问题的过度拟合一致的训练曲线？</li>
</ul>
</li>
</ul>
</li>
<li>如有必要，根据上述问题的答案，改进最近的研究（或研究组）以改进搜索空间和/或抽样更多试验，或采取其他一些纠正措施。</li>
<li>一旦我们回答了上述问题，我们就可以继续评估实验为我们最初的目标提供的证据（例如，<a href="#detecting-whether-a-change-is-useful-with-isolation-plots">评估改变是否有用</a>）。</li>
</ul>
<h4 id="识别错误的搜索空间边界"><a href="#识别错误的搜索空间边界" class="headerlink" title="识别错误的搜索空间边界"></a>识别错误的搜索空间边界</h4><ul>
<li>如果从搜索空间中采样的最佳点靠近其边界，那么这个搜索空间就有可疑之处。如果我们将搜索范围朝着这个方向扩大，我们可能会找到更优秀的点。</li>
<li>为了检查搜索空间边界，我们喜欢在被我们称之为<strong>基本超参数轴图</strong>的图表绘制已完成的试验，我们在其中绘制验证目标值与其中一个超参数（例如学习率）的关系。图中的每个点都对应于一次试验。<ul>
<li>每次试验的验证目标值通常应该是它在训练期间达到的最佳值。</li>
</ul>
</li>
</ul>
<p align="center" id="figure-1">
<img src="/img/tuning_playbook-bad_search_space.png" width="49%" alt="Example of bad search space boundaries">
<img src="/img/tuning_playbook-good_search_space.png" width="49%" alt="Example of good search space boundaries">
</p>




<p align="center"><b>图 1：</b>不良的搜索空间边界和可接受的搜索空间边界示例。</p>

<ul>
<li><a href="#figure-1">Figure 1</a>中的图表显示错误率（越低越好）与初始学习率的关系。</li>
<li>如果最佳点聚集在搜索空间的边缘（在某个维度上），则可能需要扩展搜索空间边界，直到最佳观察点不再靠近边界。</li>
<li>通常，一项研究将包括“不可行”的试验，这些试验会产生分歧或得到非常糟糕的结果（在上图中用红色 X 标记）。<ul>
<li>如果所有试验对于大于某个阈值的学习率都是不可行的，并且如果表现最好的试验在该区域的边缘具有学习率，则模型<a href="#how-can-optimization-failures-be-debugged-and-mitigated">可能遇到了稳定性问题，从而无法获得更高的学习率</a>。</li>
</ul>
</li>
</ul>
<h4 id="没有在搜索空间中采样足够的点"><a href="#没有在搜索空间中采样足够的点" class="headerlink" title="没有在搜索空间中采样足够的点"></a>没有在搜索空间中采样足够的点</h4><ul>
<li>一般来说，<a href="#how-many-trials-are-needed-to-get-good-results-with-quasi-random-search">可能很难知道</a>是否搜索空间已经被足够密集地采样。🤖</li>
<li>运行更多的试验当然更好，但代价是显而易见的。</li>
<li>由于很难知道我们什么时候采样足够，我们通常会采样我们可以负担得起的代价，并尝试通过反复查看各种超参数轴图来校准我们的直觉，并试图了解有多少点位于搜索空间的“好”区域。</li>
</ul>
<h4 id="检查训练曲线"><a href="#检查训练曲线" class="headerlink" title="检查训练曲线"></a>检查训练曲线</h4><p><strong><em>总结</em></strong>： <em>检查训练曲线是识别常见故障的一种简单方法，也可以帮助我们优先考虑下一步采取什么行动。</em></p>
<ul>
<li>虽然在许多情况下，我们实验的主要目标只需要考虑每次试验的验证误差，但在试验中将验证误差减少到固定数字时我们必须小心，因为它可以隐藏表面下发生的事情的重要细节。</li>
<li>对于每一项研究，我们总是查看至少是最好的几项试验的<strong>训练曲线</strong>（绘制的训练误差和验证误差与训练期间训练步数的关系图）。</li>
<li>即使这对于解决主要的实验目标不是必要的，但检查训练曲线是识别常见故障模式的简单方法，也可以帮助我们优先考虑下一步采取什么行动。</li>
<li>在检查训练曲线时，我们对以下问题感兴趣。</li>
<li>是否有任何试验显示<strong>过拟合</strong>？<ul>
<li>当验证误差在训练期间的某个时刻开始<em>增加</em>时，就会发生过度拟合。</li>
<li>在试验中(我们对目标超参数的不同设置选取最佳试验效果的试验[这实际上优化了冗余超参数])，我们应该<em>至少</em>在目标超参数的每个设置相对应的最佳试验中检查是否有过拟合问题。<ul>
<li>如果任何最佳试验出现过拟合问题，我们通常会在比较目标超参数的不同值之前使用额外的正则化技术重新运行实验和/或更好地调整现有的正则化参数(防止因固定超参数的设置漏掉可能的优解？)。<ul>
<li>如果目标超参数包括正则化参数，这可能不适用，因为如果这些正则化参数的低强度设置导致有问题的过拟合是不足为奇的。</li>
</ul>
</li>
<li>使用常见的正则化技术减少过度拟合通常很简单，这些技术增加了代码复杂性的下届或额外的计算（例如，dropout、标签平滑化、权重衰减），因此在下一轮实验中添加一个或多个这些通常问题不大。</li>
<li>举个例子，如果目标超参数是“隐藏层数”，当使用最大隐藏层数的最佳试验表现出过拟合问题，那么我们通常更愿意使用额外的正则化再次尝试，而不是立即选择较小数量的隐藏层。</li>
<li>即使“最佳”试验都没有表现出有过拟合，但它发生在<em>所有</em>试验中时，这就可能存在问题。<ul>
<li>选择最佳试验会抑制出现过拟合问题的配置，并偏向那些不会出现过拟合问题的配置。换句话说，它对具有更多正则化的配置更偏爱。</li>
<li>然而，任何让训练变得更糟的事情都可以作为正则化器，即使它不是故意的。例如，选择较小的学习率可以通过阻碍优化过程来规范训练，但我们通常不希望以这种方式选择学习率。</li>
<li>因此，我们必须意识到，目标超参数的每个设置的“最佳”试验是否会以有利于某些目标或冗余超参数像“坏”值的方式选择。</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li>在训练后期，训练或验证误差是否存在较高的步与步之间的<a target="_blank" rel="noopener" href="https://math.stackexchange.com/questions/3604607/can-i-work-out-the-variance-in-batches">方差</a>？<ul>
<li>如果是这样，这可能会干扰我们比较目标超参数的不同值的能力（因为每个试验都随机地在 “幸运 “或 “不幸运 “的一步上结束），以及我们在生产中重现最佳试验结果的能力（因为生产模型可能不会像研究中那样在 “幸运 “一步上结束）。</li>
<li>导致步间方差的最大可能的是Batch的方差（应当从训练集中随机抽取样本），过小的验证集，以及在训练后期使用过高的学习率。 </li>
<li>可能的补救措施包括增加Batch Size，使用更多的验证数据，使用学习率衰减，或使用Polyak平均法。</li>
</ul>
</li>
<li>训练结束时试验是否仍能改进？<ul>
<li>如果是这样，这表明我们在<a href="#determining-the-number-of-steps-for-each-training-run">“计算限制”</a>制度中，我们可能会受益于<a href="#Deciding-how-long-to-train-when-training-is-compute-bound">增加训练步数</a>或更改学习率计划。</li>
</ul>
</li>
<li>训练集和验证集的性能在最后的训练步骤之前很久就饱和了吗？<ul>
<li>如果是这样，这表明我们处于<a href="#determining-the-number-of-steps-for-each-training-run">“不受计算限制”</a>制度中，我们可能能够<a href="#deciding-how-long-to-train-when-training-is-not-compute-bound">减少训练步数</a>。</li>
</ul>
</li>
<li>虽然我们不能一一列举，但还有许多其他的行为可以通过检查训练曲线而变得明显（例如，训练误差在训练过程中增加，通常表明训练工作流中存在错误）。</li>
</ul>
<h4 id="使用isolation图检测更改是否有用"><a href="#使用isolation图检测更改是否有用" class="headerlink" title="使用isolation图检测更改是否有用"></a>使用isolation图检测更改是否有用</h4><p align="center" id="figure-2">
<img src="/img/tuning_playbook-isolation_plot.png" width="49%" alt="Isolation plot that investigates the best value of weight decay for ResNet-50 trained on ImageNet.">
</p>




<p align="center"><b>图 2：</b>研究在 ImageNet 上训练的 ResNet-50 的最佳权重衰减值的isolation图。</p>

<ul>
<li>通常，一组实验的目标是比较目标超参数的不同值。<ul>
<li>例如，我们可能想要确定导致最佳验证误差的权重衰减值。</li>
</ul>
</li>
<li><strong>isolation图</strong>是基本超参数轴图的特例。isolation图上的每个点对应着在优化某些（或全部）冗余超参数上最佳试验的性能。<ul>
<li>换句话说，我们绘制了在”优化掉”冗余超参数后模型的性能。</li>
</ul>
</li>
<li>isolation图可以更轻松地在目标超参数的不同值之间进行同类比较。</li>
<li>例如，<a href="#图2">图2</a>显示了在ImageNet上训练的ResNet-50的特定配置(学习率)下产生最佳验证性能的权重衰减值。<ul>
<li>如果我们的目标是确定是否要加入权重衰减，那么我们会将此图中的最佳点与没有权重衰减的Baseline进行比较。为了公平比较，Baseline的学习率也应该同样得到很好的调整。</li>
</ul>
</li>
<li>当我们正在考虑为一个连续的超参数来绘制isolation图时，并且我们是使用Quasi-Random-Search(近似随机搜索)产生的超参数的不同值时，我们可以通过对基本超参数轴图的X轴值进行分桶，并在分桶定义的每个垂直切片中取最佳试验来近似绘制隔离图。</li>
</ul>
<h4 id="自动化常用的绘图"><a href="#自动化常用的绘图" class="headerlink" title="自动化常用的绘图"></a>自动化常用的绘图</h4><ul>
<li>当第一次生成此类图表花费的努力越多，您查看这类图表的频率就越低。因此，最好将您的基础策略设为自动生成尽可能多的图表。</li>
<li>至少，我们会为我们在实验中变化的所有超参数自动生成基本超参数轴图。</li>
<li>此外，我们会自动为所有试验生成训练曲线，并尽可能轻松地找到每项研究中最好的几次试验并检查它们的训练曲线。</li>
<li>我们可以也添加许多其他有用的潜在图表和可视化。尽管上面的例子的是一个很好的起点，但套用杰弗里 · 辛顿 (Geoffrey Hinton) 的话，“每次设计新事物时，您都会学到新事物。”</li>
</ul>
<h3 id="确定是否采用此训练工作流更改或超参数配置"><a href="#确定是否采用此训练工作流更改或超参数配置" class="headerlink" title="确定是否采用此训练工作流更改或超参数配置"></a>确定是否采用此训练工作流更改或超参数配置</h3><p><strong><em>总结</em></strong>： <em>当决定是否对我们的模型或训练程序进行改变或采用新的超参数配置时，我们需要理解导致我们结果中不同的变化的来源。</em></p>
<ul>
<li>当我们试图改进我们的模型时，我们可能会观察到，与我们现有的配置相比，一个特定的候选变化最初取得了更好的验证误差，但在重复实验后发现，没有发现一致的优势。非正式地，我们可以把可能导致这种不一致结果的最重要的变化来源分为以下几大类。<ul>
<li><strong>训练程序方差</strong>、<strong>再训练方差</strong>或<strong>试验方差</strong>：我们在使用相同的超参数但不同的随机种子的训练运行之间看到的差异。<ul>
<li>例如，不同的随机初始化、训练数据的shuffles、dropout掩码、数据增强操作的模式和并行运算的顺序，都是试验方差的潜在来源。</li>
</ul>
</li>
<li><strong>超参数搜索方差</strong>或<strong>学习方差</strong>：由我们选择超参数的程序引起的结果变化。<ul>
<li>例如，我们可能会在特定搜索空间运行相同的实验，但使用两个不同的种子进行Quasi-Random-Search搜索，并最终选择不同的超参数值。</li>
</ul>
</li>
<li><strong>数据收集和抽样方差</strong>：训练数据、验证数据和测试数据的任何一种随机分割所产生的方差，或者更普遍的由于训练数据生成过程而产生的方差。</li>
</ul>
</li>
<li>使用严格的统计测试对有限验证集上估计的验证错误率进行比较是很好的，但往往仅试验方差就能在使用相同超参数设置的两个不同的训练模型之间产生统计上的显著差异。</li>
<li>当我们试图得出超出超参数空间中单个点水平的结论时，我们最关心的是学习方差。<ul>
<li>学习方差取决于试验次数和搜索空间，我们已经看到它大于试验方差的情况以及它小得多的情况。</li>
</ul>
</li>
<li>因此，在采用一个候选变化之前，考虑运行最佳试验N次，以估计训练方差。<ul>
<li>通常情况下，我们可以只在工作流发生重大变化后重新对试验方差进行估计，但在某些应用中，我们可能需要使用更新鲜的估计。 </li>
<li>在其他应用中，估计试验方差的成本太高，不值得这样做。</li>
</ul>
</li>
<li>归根结底，虽然我们只想采用能够产生真正改进的更改（包括新的超参数配置），但要求完全相信某些东西会有所帮助也不是正确的要求。</li>
<li>因此，如果一个新的超参数点（或其他变化）得到比Baseline更好的结果（尽可能考虑新点和Baseline的再训练方差），那么我们可能应该采用它作为新的Baseline为以后的比较。<ul>
<li>但是，我们应该只采用产生的改进超过它们增加的复杂性的更改。</li>
</ul>
</li>
</ul>
<h3 id="探索结束后"><a href="#探索结束后" class="headerlink" title="探索结束后"></a>探索结束后</h3><p><strong><em>总结</em></strong>： <em>一旦我们完成了对“好”的搜索空间的探索，并决定了哪些超参数甚至应该被调整，贝叶斯优化工具就是一个值得考虑的选择。</em></p>
<ul>
<li>在这个时候，我们的优先事项将从学习更多优化经验转向产生一个最佳配置来启动或以其他方式使用。</li>
<li>在这一点上，我们应该有一个精确的搜索空间，可以舒适地包含最佳观察试验周围的局部区域，并且已经过充分采样。</li>
<li>我们的探索工作应该已经揭示了最重要的要调整的超参数（以及它们的合理范围），我们可以使用这些超参数来构建搜索空间，以使用尽可能大的调整预算进行最终的自动调整研究。</li>
<li>由于我们不再关心最大化我们对优化问题的经验，<a href="#why-use-quasi-random-search-instead-of-more-sophisticated-black-box-optimization-algorithms-during-the-exploration-phase-of-tuning">Quasi-Random-Search的优化方式</a>不再适用，这时应该使用贝叶斯优化工具来自动找到最佳超参数配置。<ul>
<li>如果搜索空间包含大量发散点（获得 NaN 训练损失或比平均值差很多标准差的训练误差的点），使用黑盒优化工具来正确处理发散试验很重要（请参阅<a target="_blank" rel="noopener" href="https://arxiv.org/abs/1403.5607">具有未知约束的贝叶斯优化</a>是处理此问题的绝佳方法）。</li>
</ul>
</li>
<li>此时，我们还应该考虑检查测试集上的性能。<ul>
<li>原则上，我们甚至可以将验证集折叠到训练集中，并重新训练通过贝叶斯优化找到的最佳配置。但是，这只适用于未来不会有这种特定工作需求的情况（例如，单次 Kaggle 竞赛）。</li>
</ul>
</li>
</ul>
<h2 id="确定每次训练运行的步数"><a href="#确定每次训练运行的步数" class="headerlink" title="确定每次训练运行的步数"></a>确定每次训练运行的步数</h2><ul>
<li>有两种类型的工作模式：受计算限制的和不受计算限制的。</li>
<li>当训练为<strong>受计算限制</strong>时，训练受限于我们愿意等待的时间，而不是受我们拥有多少训练数据或其他因素的限制。<ul>
<li>在这种情况下，如果我们能以某种方式延长训练时间或提高训练效率，我们应该看到较低的训练损失，并且通过适当的调整，改善验证损失。</li>
<li>换句话说，加快训练速度就等于改善训练效果，而 “最佳 “训练时间总是 “我们愿意等待的时间”范围内。</li>
<li>然而，当工作模式受计算限制时，并不意味我们只能通过更长/更快的训练来改善结果。</li>
</ul>
</li>
<li>当训练为<strong>不受计算限制</strong>时，我们可以负担得起训练的时间，只要我们愿意。或在某些时候，训练更长的时间并没有多大帮助（甚至会导致过拟合）。<ul>
<li>在这种情况下，我们应该期望能够训练到非常低的训练误差，训练时间更长可能会略微减少训练误差，但不会显着减少验证误差。</li>
<li>当训练不受计算限制时，慷慨的训练时间预算可以使调整更容易，特别是在调整学习率衰减计划时，因为它们与训练预算有特别强的相互作用。<ul>
<li>换句话说，吝啬的训练时间预算可能需要将学习率衰减计划调整到完美，以实现良好的训练效果。</li>
</ul>
</li>
</ul>
</li>
<li>不管一个给定的工作负载是否是计算约束，使用增加梯度方差（跨Batch）的方法通常会导致较慢的训练进度，从而可能增加达到特定验证损失所需的训练步骤。高梯度方差可能是由以下原因造成的。<ul>
<li>使用了较小的Batch Size</li>
<li>使用了数据增强技术</li>
<li>添加了一些类型的正则化（例如 dropout）</li>
</ul>
</li>
</ul>
<h3 id="当训练不受计算限制时如何决定该训练多久"><a href="#当训练不受计算限制时如何决定该训练多久" class="headerlink" title="当训练不受计算限制时如何决定该训练多久"></a>当训练不受计算限制时如何决定该训练多久</h3><ul>
<li>我们的主要目标是确保我们训练的时间足够长，以使模型达到最佳效果，同时避免在训练步数的数量上过度浪费。</li>
<li>在有疑问的时候，请偏向于选择延长训练时间。假设回顾性（最佳）检查点选择使用得当，并且检查点足够频繁，那么训练时间越长，性能就越不会下降。</li>
<li>不要在训练中调整 <code>max_train_steps</code> 以获得更好的效果。我们只需要选择一个值并将其用于所有试验。从这些试验中，绘制回顾检查点选择发现的训练steps，以优化<code>max_train_steps</code>的数值。<ul>
<li>例如，如果最佳step总是出现在训练过程的前10%，那么最大训练step数就太高了。</li>
<li>或者，如果最好的step总是出现在训练过程的最后的25%中，我们可能可以在增加训练时间和重新调整学习率衰减策略中受益(都与max_train_steps相关)。</li>
</ul>
</li>
<li>当模型架构或数据发生变化时(例如添加数据增强)，理想的训练的step数也会发生变化。</li>
<li>下面我们将描述如何根据使用恒定学习率“完全拟合”训练集所需的step数，为<code>max_train_steps</code>选择初始候选值。<ul>
<li>注意，我们并没有以精确或数学定义良好的方式使用短语“完美拟合训练集”。<br>它只是一个非正式的描述语，表示非常低的训练损失。<ul>
<li>例如，当训练损失为log loss且没有正则化项时，我们可能会看到训练损失会一直在缓慢减小(这与log loss的特性有关)，直到达到浮点极限（floating point limits），因为网络权重可以无限制地增长，模型会对训练集的预测变得越来越自信。在这种情况下，我们可能会说，当训练集中的错误分类为0时，模型“完全拟合”训练集。</li>
</ul>
</li>
<li>如果训练过程中 gradient noise(译注：可参考Umut Simsekl et al) 增大时，则<code>max_train_steps</code>可能需要增加起始值。<ul>
<li>例如，如果在模型中引入数据增强或dropout等正则化方法。</li>
</ul>
</li>
<li>如果训练过程以某种方式改进，可能会减少<code>max_train_steps</code>。<ul>
<li>例如，使用更好的优化器或更好的学习率更新策略。</li>
</ul>
</li>
</ul>
</li>
</ul>
<h4 id="使用学习率搜索算法来确定-max-train-steps-的初始值"><a href="#使用学习率搜索算法来确定-max-train-steps-的初始值" class="headerlink" title="使用学习率搜索算法来确定 max_train_steps 的初始值"></a>使用学习率搜索算法来确定 max_train_steps 的初始值</h4><ul>
<li>此过程假设不仅可以“完美”地拟合训练集，而且可以使用恒定的学习率更新策略来实现。</li>
<li>如果可以完美地拟合整个训练集，那么<code>max_train_steps</code>应该有一个确定的值可以完美地拟合训练集；找到这个值作为<code>max_train_stepsd</code>的起点<code>N</code></li>
<li>在没有数据增强和正则化的情况下运行恒定的学习率搜索（即网格搜索学习率），其中每个试验训练 <code>N</code> 步骤。</li>
<li>在搜索中最快达到完美训练的实验所需的步数就是我们对 <code>max_train_steps</code> 的初步猜测。</li>
<li><strong>注意：</strong> 错误的搜索空间可能会导致自欺欺人。<ul>
<li>例如，如果一项研究中的所有学习率都太小，我们可能会错误地得出结论，认为一个非常大的<code>max_train_steps</code>的值是必要的。</li>
<li>至少，我们应该检查研究中的最佳学习率是否在搜索空间的边界(基本超参数轴图)。</li>
</ul>
</li>
</ul>
<h3 id="当训练受计算限制时如何决定该训练多久"><a href="#当训练受计算限制时如何决定该训练多久" class="headerlink" title="当训练受计算限制时如何决定该训练多久"></a>当训练受计算限制时如何决定该训练多久</h3><ul>
<li>在某些情况下，训练误差会无限地改善，而我们的耐心和计算资源就成为了限制因素。</li>
<li>如果训练误差（或甚至验证误差）可以无限地改善，我们是否应该在我们能接受的情况下一直训练？答案是不必要。<ul>
<li>通过运行更多的短时间的实验，我们可以更快地找到最佳的模型和优化器超参数，而不必浪费大量的计算资源和时间在不优秀的超参数上。最后，我们可能会运行少量的长时间(“production length” 指模型在生产环境中运行的时间,也就是预期的长时间训练)的实验来在最佳超参数点上获得最终模型。这样，我们就可以更有效地使用我们的资源来调整最有可能在生产环境中表现良好的模型。</li>
<li>我们的训练时间越长，我们对模型的理解就会越深入，这样我们就可以更好的了解模型的性能和限制，因此我们可以更确定哪些参数是最有可能在生产环境中表现良好的参数。但是，当我们的训练时间越长，我们能完成的实验就会越少，因为我们的耐心和计算资源有限。</li>
<li>当我们只训练 ~10% 的production length时，我们可能能够回答很多问题，但是在这个时间限制下的结论不一定适用于20%的production length的实验，更不用说100%了。这是因为训练模型的时间越长，模型就会越来越接近其最佳性能，而在较短的训练时间内得出的结论可能不能完全适用于长时间训练后的模型。</li>
</ul>
</li>
<li>因此我们建议在每轮调整中逐渐增加训练步数限制，以在有限的资源和耐心内获得最大的理解，并在最终长时间训练后再进行验证和确认。<ul>
<li>我们可以想做多少轮就做多少轮，但通常 1-3 轮是最实用的。</li>
<li>从本质上讲，在进行调整时要在两个方面进行平衡：相关性和彻底性。相关性指的是调整结果与最终长时间运行之间的相似性，而彻底性则指调整结果的详尽程度。因此，在进行调整时，我们应该尽量使用快速转换时间的试验来获得尽可能多的问题理解，同时保证这些结论与最终长时间运行相关。这样可以在有限的时间和资源内获得最大的理解，并尽可能地减少对最终长时间运行的影响。</li>
<li>一旦给定的每次试验时间限制中产生了有用的见解，我们就可以增加训练时间并继续调整，以确保它们在长时间运行中仍然适用。</li>
</ul>
</li>
<li>作为起点，我们建议进行两轮调整：<ul>
<li>第一轮：进行短时间的训练来找到较佳的模型和优化器超参数</li>
<li>第二轮：在较佳的超参数上进行少量长时间的训练来得到最终模型</li>
</ul>
</li>
<li>从 <code>Round i</code> → <code>Round i+1</code> 的最大问题是如何调整学习率衰减计划。<ul>
<li>在进行调整时，最大的问题是如何调整学习率衰减计划。在调整学习率衰减计划时的一个常见问题是使用了太小的学习率，如果学习率过小，模型的收敛速度会变慢，可能会需要更多的训练步骤才能达到最优状态。这可能会增加训练时间并增加计算资源的需求。</li>
</ul>
</li>
</ul>
<h4 id="第一轮"><a href="#第一轮" class="headerlink" title="第一轮"></a>第一轮</h4><ul>
<li>遗憾的是，在短时间和不完整训练中找到的超参数在增加训练长度后仍然是好选择的保证是没有的。但是，对于某些类型的超参数，它们通常具有足够的相关性，因此第一轮非常有用。</li>
<li>我们期望在短运行中找到的哪些超参数值会转移到更长的训练运行中？对于这一切，我们需要更多的研究。但是根据已有的结论我们可以提出一些猜测，以下是作者的猜测，按转移概率的降序排列：<ul>
<li>极有可能转移<ul>
<li>在第一轮调参中，使用较少的训练步数可以解决早期训练的不稳定性。也许这些超参数是最能保证转移的选择。<ul>
<li>Warmup时长</li>
<li>模型参数初始值</li>
</ul>
</li>
</ul>
</li>
<li>可能转移<ul>
<li>模型架构 - 模型架构上的显著胜利通常会转移，但可能有很多例外。</li>
</ul>
</li>
<li>可能会转移<ul>
<li>优化算法/优化器超参数——我们认为这将”松散”转移。它明显比上面的东西弱。</li>
<li>数据增强方法</li>
<li>正则化<ul>
<li>如果不可能完美地拟合训练集，则模型可能处于正则化不太可能有太大的帮助。</li>
</ul>
</li>
</ul>
</li>
<li>不太可能转移<ul>
<li>学习率衰减计划：不太可能完美迁移。<ul>
<li><a target="_blank" rel="noopener" href="https://arxiv.org/abs/2203.15556">This paper</a>说学习率衰减计划也能转移。但我们不相信这在通常情况下是正确的。例如：在较少的训练步骤上调整开根号衰减，然后扩展到大量训练步骤将导致在过小的步骤上进行大部分训练。<ul>
<li>在极端训练预算限制下，可能可以用大多数计划做到“足够好”，但如果进行了调整，可能会看到明显的性能改进。</li>
</ul>
</li>
<li><a target="_blank" rel="noopener" href="https://arxiv.org/abs/1803.02021">了解随机元优化中的短期偏差</a>描述了选择学习率的短视危险。</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<h4 id="第二轮"><a href="#第二轮" class="headerlink" title="第二轮"></a>第二轮</h4><ul>
<li>运行第一轮中最佳的超参数配置。</li>
<li><strong>（推测）</strong> 🤖使用额外的步骤来延长高学习率的训练时间。<ul>
<li>例如，如果是线性计划，则保持第一轮中衰减大小的固定值，并在开始时延长恒定的lr期。</li>
<li>对于余弦衰减，只需保留第一轮的基础 lr 并像<a target="_blank" rel="noopener" href="https://arxiv.org/abs/2203.15556"> Chinchilla 论文 </a>一样增大 <code>max_train_steps</code>。</li>
</ul>
</li>
<li>对于具有非常成熟建模和调整的工作流以及非常长且昂贵的生产训练运行的团队来说，更多回合可能更有意义，但它们通常会过于复杂。<ul>
<li>我们已经描述了如何从第一轮  → 第二轮 进行转换。如果我们不关心分析时间，并且计算效率是关键因素，那么理想情况是在许多不同的调整轮次中逐渐增加训练运行的长度(从而增加完成研究的总体时间)。<ul>
<li>在每一轮中，我们都系统地确保我们的选择仍然是正确的。</li>
<li>新的想法经过一个完整的工作，越来越长时间的实验逐渐降低了它不可用的风险。</li>
</ul>
</li>
</ul>
</li>
</ul>
<h2 id="关于训练管道的额外补充"><a href="#关于训练管道的额外补充" class="headerlink" title="关于训练管道的额外补充"></a>关于训练管道的额外补充</h2><h3 id="优化输入管道"><a href="#优化输入管道" class="headerlink" title="优化输入管道"></a>优化输入管道</h3><p><strong><em>总结</em></strong>： <em>输入管道性能受限的原因及干预措施与具体任务高度相关，使用性能分析工具并注意常见的一些问题。</em></p>
<ul>
<li>使用适当的性能分析工具来诊性能受限的输入管道，例如，用于 JAX 的 <a target="_blank" rel="noopener" href="https://jax.readthedocs.io/en/latest/profiling.html">Perfetto</a> 或用于 TensorFlow 的 <a target="_blank" rel="noopener" href="https://www.tensorflow.org/guide/profiler">TensorFlow profiler</a>。</li>
<li>归根结底，具体原因和干预措施将高度依赖于任务。更广泛的工程考虑(如减少磁盘空间占用)可能会导致较差的输入管道性能。</li>
<li>常见问题：<ul>
<li>数据未与训练进程存放在同一位置，从而导致I/O延迟(通过网络读取训练数据时可能会发生这种情况)。</li>
<li>昂贵的在线数据预处理(考虑进行一次性离线预处理并保存)。</li>
<li>无意间的同步屏障干扰数据管道预读取。例如，在 CommonLoopUtils(<a target="_blank" rel="noopener" href="https://github.com/google/CommonLoopUtils/blob/fea2518ada8814a78e1492023fd9f00edb0b0568/clu/metrics.py#L291">link</a>) 中同步设备和主机之间的数据时。</li>
</ul>
</li>
<li>常见技巧：<ul>
<li>例如使用 <a target="_blank" rel="noopener" href="https://www.tensorflow.org/guide/data_performance#prefetching">tf.data.Dataset.prefetch</a> 之类的工具对输入管道预读取数据。</li>
<li>尽可能早地在管道中删除不必要的特征和元数据。</li>
<li>通过使用 <a target="_blank" rel="noopener" href="https://www.tensorflow.org/api_docs/python/tf/data/experimental/service">tf.data service</a> 来增加输入管道生成数据的进程的数量。</li>
</ul>
</li>
</ul>
<h3 id="评估模型性能"><a href="#评估模型性能" class="headerlink" title="评估模型性能"></a>评估模型性能</h3><p><strong><em>总结</em></strong>： <em>使用比训练时更大的 batch size 进行评估。在固定步长间隔进行评估，而不是固定的时间间隔。（注：如100个epoch评估一次，而不是10分钟评估一次）。</em></p>
<h4 id="评估设置"><a href="#评估设置" class="headerlink" title="评估设置"></a>评估设置</h4><ul>
<li>我们可以通过多种方式来评估模型的性能。<ul>
<li>在线评估-当模型在生产环境中提供预测时收集指标。</li>
<li>离线评估-当模型在代表生产环境的离线训练/验证/测试集上运行时，收集指标。</li>
<li>定期评估-在模型训练期间收集的指标可能是离线评估的代理，和(或)离线评估中使用的数据的子集。</li>
</ul>
</li>
<li>在线评估是最佳标准，但在模型开发阶段往往是不切实际的。</li>
<li>根据问题的不同，离线评估可能会相当复杂，并且计算成本很高。</li>
<li>定期评估是最实际和最经济的选择，但可能不能完全代表生产环境。<ul>
<li>我们在定期评估时的目标是在训练期间获得可靠信号，使同时尽可能缩短评估时间。</li>
</ul>
</li>
</ul>
<h4 id="设置定期评估"><a href="#设置定期评估" class="headerlink" title="设置定期评估"></a>设置定期评估</h4><ul>
<li>我们在训练期间定期进行评估，以实时监控其进度，以便于<a target="_blank" rel="noopener" href="https://github.com/google-research/tuning_playbook#:~:text=facilitate%20retrospective%20model%20checkpoint%20selection">追溯模型检查点选择</a>，以便我们可以在<a target="_blank" rel="noopener" href="https://github.com/google-research/tuning_playbook#:~:text=examine%20the%20training%20curves%20at%20the%20end%20of%20training">训练结束时检查训练曲线</a>。</li>
<li>其中最简单的配置是在同一计算实例中执行训练和定期评估，并定期在训练和评估之间交替。(注：比如固定步长间隔评估一次）</li>
<li>在这种情况下，用于执行评估的 batch size 大小应该至少与用于训练的 batch size 大小一样大，因为在评估期间不需要保持模型运行（注：如不用计算梯度之类的），从而降低了每个示例的计算要求。</li>
<li>定期评估应在固定步长间隔进行，而不是按时间间隔进行。<ul>
<li>基于时间间隔进行评估可能会使解释训练曲线变得更加困难，尤其是在培训可能受到训练作业抢占、网络延迟问题等影响的情况下。</li>
<li>有效/测试度量中的周期性(当使用打乱后的训练/确认/测试分割时)可以指出某些实现错误，例如测试数据与训练数据重叠，或者训练数据没有被适当地打乱。这些问题可以通过在固定步长间隔进行评估来更容易地检测到。</li>
<li>当评估集不能被 batch size 整除时，会出现部分 batch 的情况。确保填充的数据被正确地加权，以防止损失函数产生偏向。通常，这些填充的数据可以被赋予零的权重。</li>
<li>最后，保存每次评估的足够信息，以支持离线分析。理想情况下，我们将保存一些单个示例的预测，因为它们对于调试来说非常有价值。<ul>
<li>生成像 <a target="_blank" rel="noopener" href="https://www.tensorflow.org/guide/saved_model">SavedModels</a> 这样的构件可以轻松地在评估完成后进行即时模型检查。</li>
</ul>
</li>
</ul>
</li>
</ul>
<h4 id="选择样本进行定期评估"><a href="#选择样本进行定期评估" class="headerlink" title="选择样本进行定期评估"></a>选择样本进行定期评估</h4><ul>
<li>定期评估作业的运行速度可能不够快，无法在合理的时间内计算完整离线评估集的指标。这通常需要对数据进行抽样以进行定期评估。</li>
<li>在构建采样数据集时，我们会考虑以下因素：<ul>
<li><u>样本量</u><ul>
<li>确保定期作业使用的采样数据集的性能与整个离线评估集的性能相似，确保采样集与完整数据集之间没有偏差。</li>
<li>用于定期评估的数据集应该足够小，以便很容易生成整个模型的预测，但也应该足够大，以便可以准确地测量模型的改进(即不被大量标签噪声影响)。</li>
<li>它应该足够大，以适应顺序试验中的多个这样的评估，并仍然产生准确的估计。也就是说，避免在多轮评估中对验证集过度适应，从而影响模型对留出集的表现。然而，这种考虑很少是一个实际的问题。</li>
</ul>
</li>
<li><u>不平衡的数据集</u><ul>
<li>对于不平衡的数据集，在稀有类别样本上的表现往往会有噪音。</li>
<li>对于每个类别只有少量样本的数据集，记录正确预测样本的数量，可以更深入地了解准确性改进(.05灵敏度改进听起来很令人兴奋，但它只是因为更多的样本被正确预测了吗？)</li>
</ul>
</li>
</ul>
</li>
</ul>
<h3 id="保存检查点并追溯选择最佳检查点"><a href="#保存检查点并追溯选择最佳检查点" class="headerlink" title="保存检查点并追溯选择最佳检查点"></a>保存检查点并追溯选择最佳检查点</h3><p><strong><em>总结</em></strong>：<em>运行固定步长的训练，并回顾性地从中选择最佳检查点。</em></p>
<ul>
<li>大多数深度学习框架都支持<a target="_blank" rel="noopener" href="https://flax.readthedocs.io/en/latest/api_reference/flax.training.html">模型检查点</a>。模型的当前状态会定期保存在磁盘上。这允许训练作业对计算实例中断具有弹性。</li>
<li>最佳检查点并不一定是最后一个检查点，尤其是当验证集性能不会随时间持续增加而是围绕特定值波动时。</li>
<li>设置管道以跟踪到目前为止在训练期间看到的 N 个最佳检查点。在训练结束时，模型选择就是选择训练期间看到的最佳检查点。我们将此称为 <strong>回顾性最佳检查点选择</strong>。</li>
<li>因为预先指定了试验预算并保留了迄今为止看到的 N 个最佳检查点，所以通常不必要支持预期提前停止。</li>
</ul>
<h3 id="设置实验跟踪"><a href="#设置实验跟踪" class="headerlink" title="设置实验跟踪"></a>设置实验跟踪</h3><p><strong><em>总结</em></strong>：<em>在跟踪不同的实验时，一定要注意一些要点，比如研究中检查点的最佳性能，以及对研究的简短描述。</em></p>
<ul>
<li>我们发现，在电子表格中跟踪实验结果有助于我们解决各种建模问题。它通常有以下列：<ul>
<li>实验名称</li>
<li>实验配置存储位置的链接</li>
<li>实验的注释或简短描述</li>
<li>运行次数</li>
<li>最佳模型在验证集上的表现</li>
<li>训练所需的配置和运行命令</li>
</ul>
</li>
<li>选择一种跟踪系统，能够满足上述信息的记录要求并且对使用者友好易用是非常重要的，未经记录的实验可能不会得到重视。</li>
</ul>
<h3 id="BatchNorm的实现细节"><a href="#BatchNorm的实现细节" class="headerlink" title="BatchNorm的实现细节"></a>BatchNorm的实现细节</h3><p><strong><em>总结</em></strong>：<em>目前Batch Norm通常可以用Layer Norm代替，但在不能替换的情况下，在更改批大小或主机数量时会有一些棘手的细节。</em></p>
<ul>
<li>Batch norm 使用当前批次的均值和方差对激活值进行归一化，但在多设备设置中，除非明确同步处理，否则这些统计数据在每个设备上都是不同的。</li>
<li>据说（主要在ImageNet上）仅使用约 64 个样本计算这些归一化统计数据在实际应用中效果更好（请参阅 <a target="_blank" rel="noopener" href="https://arxiv.org/abs/1705.08741">Ghost Batch Norm</a>）。</li>
<li>将总批大小与用于计算批归一化统计数据的样本数量分离对于批次大小的比较特别有用。</li>
<li>Ghost batch norm 实现并不总能正确处理每台设备的批次大小 &gt; 虚拟批次大小的情况。在这种情况下，我们实际上需要在每个设备上对批次进行二次抽样，以获得适当数量的批归一化统计样本。</li>
<li>在测试模式中使用的指数移动平均(EMA）仅仅是训练统计数据的线性组合，因此这些 EMA 只需要在将它们保存在检查点之前进行同步。然而一些常见的批归一化实现不同步这些EMA，并只保存第一个设备的EMA。</li>
</ul>
<h3 id="多主机管道的考虑因素"><a href="#多主机管道的考虑因素" class="headerlink" title="多主机管道的考虑因素"></a>多主机管道的考虑因素</h3><p><strong><em>总结</em></strong>： <em>在日志记录、评估、RNG(随机数生成器)、检查点和数据分片方面，多主机训练非常容易引入错误！</em></p>
<ul>
<li>保证管道只在一台主机上进行日志记录和检查点</li>
<li>确保在运行评估或检查点之前，批处理规范统计信息在主机之间同步</li>
<li>保证在多主机之间使用相同的随机数生成器种子(用于模型初始化)和不同的种子(用于数据混洗和预处理)是非常重要的，因此请确保合适地标记它们</li>
<li>为了提升性能，通常建议将数据文件在多台主机之间进行分片</li>
</ul>
<h2 id="常见问题的回答"><a href="#常见问题的回答" class="headerlink" title="常见问题的回答"></a>常见问题的回答</h2><h3 id="最好的学习率衰减方案是什么"><a href="#最好的学习率衰减方案是什么" class="headerlink" title="最好的学习率衰减方案是什么"></a>最好的学习率衰减方案是什么</h3><ul>
<li>这是一个开放性问题。目前尚不清楚如何构建一组严格的实验来自信地回答最佳的LR 衰减方案是什么。</li>
<li>虽然我们不知道最好的方案是什么，但我们相信尝试一些（非恒定的）方案很重要并且调整它很重要。</li>
<li>在优化过程中，不同的学习率在不同的时间效果最好。 有某种衰减方案可以使模型更有可能达到良好的学习率。</li>
</ul>
<h3 id="我应该使用哪种学习率衰减方案作为默认值？"><a href="#我应该使用哪种学习率衰减方案作为默认值？" class="headerlink" title="我应该使用哪种学习率衰减方案作为默认值？"></a>我应该使用哪种学习率衰减方案作为默认值？</h3><ul>
<li>我们的偏好是linear decay或cosine decay，其他一些方案可能也不错。</li>
</ul>
<h3 id="为什么有些论文有复杂的学习率衰减方案？"><a href="#为什么有些论文有复杂的学习率衰减方案？" class="headerlink" title="为什么有些论文有复杂的学习率衰减方案？"></a>为什么有些论文有复杂的学习率衰减方案？</h3><ul>
<li>具有复杂分段学习率 (LR) 衰减方案的论文并不少见。</li>
<li>读者常常想知道作者是如何得出如此复杂的研究结果的。</li>
<li>许多复杂的 LR 衰减方案是根据验证集性能以临时方式调整衰减方案的结果：<ol>
<li>使用一些简单的 LR 衰减（或恒定学习率）开始执行单次训练。</li>
<li>继续训练，直到性能提升似乎停滞为止。如果发生这种情况，请暂停训练。 从此时开始，使用可能更陡峭的 LR 衰减方案（或更小的恒定学习率）恢复它。 重复此过程，直到会议/发布截止日期。</li>
</ol>
</li>
<li>随意复制生成的衰减方案通常不是一个好主意，因为最佳的特定衰减方案将对许多其他超参数选择敏感。<ul>
<li>最好复制生成衰减方案的算法，尽管在人为判断生成的衰减方案时这几乎不可能。</li>
</ul>
</li>
<li>如果这种类型的验证错误敏感计划可以完全自动化，则可以很好地使用，但作为验证错误函数的人在循环计划是脆弱的并且不容易重现，因此我们建议避免使用它们。<ul>
<li>在发布使用此类衰减方案的结果之前，请尽量确保其可重现性。</li>
</ul>
</li>
</ul>
<h3 id="Adam-的超参数应该如何调整？"><a href="#Adam-的超参数应该如何调整？" class="headerlink" title="Adam 的超参数应该如何调整？"></a>Adam 的超参数应该如何调整？</h3><ul>
<li>正如之前讨论的那样, 对搜索空间以及应该从搜索空间中采样数量做出概括性陈述是非常困难的。 请注意，并非 Adam 中的所有超参数都一样重要。 以下经验法则对应于研究中试验次数的不同“预算”。<ul>
<li>如果在一次研究中，训练次数试验次数小于10，那么只需要对基本学习率进行调整。</li>
<li>如果试验次数在10到25次之间， 那么需要对学习率以及 $\beta_1$ 进行调整。</li>
<li>如果试验次数在25次以上，那么需要对学习率、 $\beta_1$ 以及 $\epsilon$ 进行调整。</li>
<li>如果可以运行的试验次数大于25次，还需要额外调整$\beta_2$。</li>
</ul>
</li>
</ul>
<h3 id="为什么在优化的探索阶段使用Quasi-Random-Search而不是更复杂的黑盒优化算法？"><a href="#为什么在优化的探索阶段使用Quasi-Random-Search而不是更复杂的黑盒优化算法？" class="headerlink" title="为什么在优化的探索阶段使用Quasi-Random-Search而不是更复杂的黑盒优化算法？"></a>为什么在优化的探索阶段使用Quasi-Random-Search而不是更复杂的黑盒优化算法？</h3><ul>
<li>Quasi-Random-Search（基于<a target="_blank" rel="noopener" href="https://en.wikipedia.org/wiki/Low-discrepancy_sequence">低差异序列</a>）<br>是我们在用作迭代调优过程的一部分时优于更高级的黑盒优化工具，旨在最大限度地洞察调优问题（我们称之为“探索阶段”）。贝叶斯优化和与其类似的工具更适合开发阶段。</li>
<li>基于随机移动的低差异序列的Quasi-Random-Search可以被认为是“抖动的、打乱的网格搜索”，因为它统一但随机地探索给定的搜索空间，并且搜索点更为分散。</li>
<li>与更复杂的黑盒优化工具（例如贝叶斯优化、遗传算法）相比，Quasi-Random-Search的优势包括：<ol>
<li>非自适应地采样搜索空间可以在不重新运行实验的情况下更改性能指标。<ul>
<li>例如，我们通常希望根据任何训练点上达到的验证误差来找到最佳试验。但是Quasi-Random-Search的非自适应性质使得我们可以基于最终验证误差、训练误差或某些替代评估指标来找到最佳试验，而不需要重新运行任何实验。(译注：假设你正在训练一个深度学习模型，并使用随机搜索来调整超参数。在第一次实验中，你使用随机搜索来寻找最优的超参数组合，并使用验证误差作为评估指标。你找到了一组超参数，使得验证误差最小。现在，你想要更改评估指标，而不是使用验证误差，而是使用训练误差(可能你在解决某种模型需求)。由于你使用的是非自适应随机搜索，因此你可以在不重新运行实验的情况下，使用已经运行的实验中的数据来评估每一组超参数的训练误差。这样你就可以找到最优的超参数组合，并且可以使用训练误差作为评估指标。这样的好处在于，你可以在不重新运行实验的情况下，使用不同的评估指标来评估这些结果，从而找到最优的实验。相比之下，如果我们使用自适应随机搜索来调参，我们会根据之前实验的结果来动态调整采样策略这导致我们不能随意的更换目标，因为采样空间已经变化)</li>
</ul>
</li>
<li>Quasi-Random-Search以一致且数据上可重现的方式运行。<ul>
<li>即使在搜索算法实现发生变化的情况下，只要它保持相同的均匀性，就应该可以重现六个月前的研究。 如果使用复杂的贝叶斯优化软件，实现可能会在版本之间发生重大变化，从而使旧搜索更难重现。 并非总是可以回滚到旧的实现（例如，如果优化工具作为服务运行）。</li>
</ul>
</li>
<li>它对搜索空间的统一探索使得对结果以及它们可能对搜索空间提出的建议的推理变得更容易。<ul>
<li>例如，如果Quasi-Random-Search遍历中的最佳点位于搜索空间的边界，这是一个很好的（但不是万无一失的）信号，这表明应该更改搜索空间边界。我们在<a href="#识别错误的搜索空间边界">这一节</a>会对此进行进一步探讨。 然而，自适应黑盒优化算法可能会因为一些不幸的早期试验而忽略了搜索空间的中间部分，尽管它包含相同优秀的点。因为正是这种不均匀性才是一个好的优化算法所需要的，它能加快搜索。</li>
</ul>
</li>
<li>与自适应算法相比，在使用Quasi-Random-Search（或其他非自适应搜索算法）时，并行运行与顺序运行不同数量的试验不会产生统计上不同的结果(这种误差会造成优化效果变差)。</li>
<li>更复杂的搜索算法可能并不总能正确处理不可行的点，特别是如果它们在设计时未考虑神经网络超参数调整。</li>
<li>Quasi-Random-Search很简单，在许多调优试验并行运行时特别高效。<ul>
<li>实际上 <sup><a href="#fn_3" id="reffn_3">3</a></sup>，自适应算法很难击败预算是其两倍的Quasi-Random-Search，尤其是当许多试验需要并行运行时（因此当启动新试验时，很难利用先前的试验结果）。</li>
<li>如果没有贝叶斯优化和其他高级黑盒优化方法方面的专业知识，我们可能无法获得它们理论上能够提供的优势。 在实际的深度学习超参数调优条件下，很难对高级黑盒优化算法进行benchmark测试。 它们是当前研究中非常活跃的领域，对于没有经验的用户来说，更复杂的算法也有其自身的缺陷。 这些方法的专家能够获得良好的结果，但在高并行条件下，搜索空间和预算往往更为重要。</li>
</ul>
</li>
</ol>
</li>
<li>这也就是说，如果我们的计算资源只允许少量试验并行运行，但我们能够按顺序运行许多试验。那么对我们来说，贝叶斯优化就会显得更具吸引力，尽管这会让我们更难解释我们的调优结果。</li>
</ul>
<blockquote id="fn_3">
<sup>3</sup>. Ben Recht 和 Kevin Jamieson<a href="#reffn_3" title="Jump back to footnote [3] in the text."> &#8617;</a>
</blockquote>
<p><a target="_blank" rel="noopener" href="http://www.argmin.net/2016/06/20/hypertuning/">指出</a> 使用2倍预算随机搜索作为Baseline有多强大（<a target="_blank" rel="noopener" href="https://jmlr.org/papers/volume18/16-558/16-558.pdf">Hyperband的论文</a>也有类似的观点），但肯定有可能找到最先进的贝叶斯优化技术可以击败两倍预算随机搜索的搜索空间和问题。然而，根据我们的经验，在高并行机制中击败 2 倍预算的随机搜索变得更加困难，因为贝叶斯优化没有机会观察先前试验的结果。</p>
<h3 id="在哪里可以找到Quasi-Random-Search的实现？"><a href="#在哪里可以找到Quasi-Random-Search的实现？" class="headerlink" title="在哪里可以找到Quasi-Random-Search的实现？"></a>在哪里可以找到Quasi-Random-Search的实现？</h3><ul>
<li>我们可以使用<a target="_blank" rel="noopener" href="https://github.com/mlcommons/algorithmic-efficiency/blob/main/algorithmic_efficiency/halton.py">这个实现</a>。它能够在给定搜索空间内生成（旨在按照<a target="_blank" rel="noopener" href="https://arxiv.org/abs/1706.03200中建议来实现移位的、加扰的">https://arxiv.org/abs/1706.03200中建议来实现移位的、加扰的</a> Halton 序列）。</li>
<li>如果基于低差异序列的Quasi-Random-Search算法不可用，则可以换成伪随机均匀搜索，虽然这可能效率稍低。<ul>
<li>在 1-2 维中，网格搜索也是可以接受的，尽管在更高的维度中不行（详见<a target="_blank" rel="noopener" href="https://www.jmlr.org/papers/v13/bergstra12a.html">Bergstra &amp; Bengio, 2012</a>）。</li>
</ul>
</li>
</ul>
<h3 id="需要多少次试验才能通过Quasi-Random-Search获得较好的结果？"><a href="#需要多少次试验才能通过Quasi-Random-Search获得较好的结果？" class="headerlink" title="需要多少次试验才能通过Quasi-Random-Search获得较好的结果？"></a>需要多少次试验才能通过Quasi-Random-Search获得较好的结果？</h3><p align="center">
<img src="/img/tuning_playbook-have_we_sampled_enough.png" width="49%" alt="A box plot showing the importance of sampling enough">
</p>

<p align="center"><b>Figure 3:</b> ResNet-50 在 ImageNet 上进行了 100 次试验调整。 通过自举，模拟了不同数量的调整预算。 上面绘制了每个试验预算的最佳性能的箱线图。

-   这个问题没有办法笼统地回答，但是我们可以看具体的例子。
-   正如Figure 3所示那样, 研究中的试验次数会对结果产生重大影响。
    -   请注意，当对6个试验进行抽样时，与对20个试验进行抽样时的四分位间距有多大的区别。
    -   即使进行了20次试验，运气特别好和运气特别差的研究之间的差异也可能大于使用固定超参数在不同随机种子上重新训练该模型之间的典型差异，对于此工作量可能约为 +/- 0.1% 的验证误差的概率约为 23%。


### 如何调试和缓解优化失败


***总结***： *如果在优化模型时遇到困难，那么在尝试其他东西之前解决这些问题很重要。 诊断和纠正训练失败是一个活跃的研究领域。*

<p align="center">
<img src="/img/tuning_playbook-stride_instability.png" width="80%" alt="Changing the strides in a single residual block in a WideResnet results in training instability.">
</p>


<p align="center"><b>Figure 4:</b> 在 WideResnet 中更改单个残差块 (2x2 -> 1x1) 中的步幅会导致训练不稳定。 这不会降低在低学习率下的性能，但由于不稳定的影响，高学习率不再能很好地进行训练。 使用1000步的学习率预热可以解决这种特殊的不稳定情况，允许以 0.1 的最大学习率进行稳定训练。</p>

<h4 id="识别不稳定的训练任务"><a href="#识别不稳定的训练任务" class="headerlink" title="识别不稳定的训练任务"></a>识别不稳定的训练任务</h4><ul>
<li>当学习率过大时，任何训练任务都会变得不稳定，但当不稳定迫使我们使用太小的学习率时，这才会是问题</li>
<li>这里至少有两种类型的不稳定的训练任务值得需要进行区分：<ol>
<li>初始化/训练早期中存在的不稳定。</li>
<li>训练中期突然出现的不稳定。</li>
</ol>
</li>
<li>我们可以采用系统的方法来找出训练任务中存在的稳定性问题.<ol>
<li>进行一次学习率扫描(不考虑学习率衰减的固定学习率)，并找到最佳的学习率 lr*.</li>
<li>绘制学习率略高于 lr* 的训练损失曲线。</li>
<li>如果学习率大于 lr* 的训练损失曲线显示不稳定（误差在训练期间上升而不下降），那么修复不稳定性可能会得到更好的训练结果(说明我们最佳的学习率比较临界)。</li>
</ol>
</li>
<li>在训练过程中记录全损失梯度的 L2 范数的变化(全损失梯度的 L2 范数是指在深度学习中，对于每个参数的梯度进行平方并相加后再取平方根的过程，反映了损失函数在当前状态下沿着梯度方向的变化程度。当前状态下的梯度向量越大，说明当前状态下的模型参数需要更大的更新量才能更好的逼近最优解)，如果我们发现全损失梯度的 L2 范数异常值非常大，这可能表明模型参数在某一时刻发生了非常大的变化，导致训练过程中出现不稳定性（例如误差上升而不下降）。 这可以告诉我们该如何选择梯度/更新剪辑。</li>
</ul>
<p><strong>注意：</strong> 某些模型会在非常早期的阶段显示出不稳定的情况，随后出现恢复，这会导致出现缓慢但稳定的训练(这可能会成为问题)。 <strong>常见的评估方法可能会因为评估不够频繁而错过这些问题！</strong></p>
<p>为了检查出这一问题，我们可以使用 <code>lr = 2 * current best</code> 来进行一次仅包含500次训练的计划，但每执行一次训练都要进行一次评估。</p>
<p align="center">
<img src="/img/tuning_playbook-more_frequent_evals.png" width="80%" alt="Illustration of the value of more frequent evaluations at the start of
training.">
</p>

<p align="center"><b>Figure 5:</b> 该图展示的是训练开始时频繁更新评估的结果。如果怀疑模型受到早期训练不稳定的影响，则很有用。</p>

<h4 id="常见不稳定模式的潜在修复方式"><a href="#常见不稳定模式的潜在修复方式" class="headerlink" title="常见不稳定模式的潜在修复方式"></a>常见不稳定模式的潜在修复方式</h4><ul>
<li>使用学习率预热<ul>
<li>最适合用于早期训练不稳定的情况。</li>
</ul>
</li>
<li>使用梯度截断<ul>
<li>对于早期和中期训练中不稳定情况都有好处，可能会解决一些学习率预热无法解决的问题。</li>
</ul>
</li>
<li>尝试使用新的优化器<ul>
<li>Adam 有时可以处理一些 Momentum 无法处理的不稳定影响。这也是该领域的一个活跃研究领域。</li>
</ul>
</li>
<li>确保使用最佳实践/初始化：<ul>
<li>例如，如果模型中尚未包含残差连接和归一化，则添加它们。</li>
</ul>
</li>
<li>归一化应该是残差之前的最后一个操作。例如， x +Norm(f(x))。</li>
<li>众所周知，Norm(x + f(x)) 会引起问题。(译注：Norm相当于白化，意在降低层参数的训练敏感性，而残差大大增加了训练参的敏感性，所有在残差前的f(x)归一化有助于降低不稳定性)</li>
<li>尝试将残差调控因子初始化为 0 （例如，<a target="_blank" rel="noopener" href="https://arxiv.org/abs/2003.04887">ReZero init所示</a>）$\boldsymbol{x}_{i+1}=\boldsymbol{x}_i+\alpha_i F\left(\boldsymbol{x}_i\right)$.</li>
<li>降低学习率<ul>
<li>这是最终手段。</li>
</ul>
</li>
</ul>
<h4 id="学习率预热"><a href="#学习率预热" class="headerlink" title="学习率预热"></a>学习率预热</h4><p align="center">
<img src="/img/tuning_playbook-instability_during_warmup.png" width="80%" alt="An example of instability during a warmup period (note the horizontal axis log
scale).">
</p>
<p align="center"><b>Figure 6:</b> 预热期间不稳定的示例（注意横轴的刻度是以对数的形式展示）。 在这种情况下，成功训练需要4万次的预热。</p>


<h5 id="何时对学习率进行预热"><a href="#何时对学习率进行预热" class="headerlink" title="何时对学习率进行预热"></a>何时对学习率进行预热</h5><p align="center">
<img src="/img/tuning_playbook-axis_model_with_instability.png" width="49%" alt="Axis plot for model with instability">
</p>

<p align="center"><b>Figure 7a:</b> 表现出训练不稳定性的模型的超参数轴图示例。 最佳学习率处于可行的边缘。 “不可行”试验被定义为产生 NaN 或异常高的损失值的试验。</p>

<p align="center">
<img src="/img/tuning_playbook-loss_model_with_instability.png" width="49%" alt="Loss curve for model with instability">
</p>

<p align="center"><b>Figure 7b:</b> 模型训练损失中不稳定的学习率</p>

<ul>
<li>Figure 7a 展示的是一个超参数轴图，该图表明模型正在经历训练不稳定，因为最佳学习率恰好位于可行的边缘。</li>
<li>Figure 7b展示了以5-10倍的峰值学习率来训练模型中产生的训练损失是如何通过双重检查的。如果该图展示的训练损失在稳步下降后突然上升（例如，如图中10000步处展示的那样），那么该模型可能存在着优化不稳定性的情况。<h5 id="如何对学习率进行预热"><a href="#如何对学习率进行预热" class="headerlink" title="如何对学习率进行预热"></a>如何对学习率进行预热</h5></li>
</ul>
<p align="center">
<img src="/img/tuning_playbook-beneficial_effect_warmup.png" width="80%" alt="Beneficial effect of warmup on training instabilities">
</p>

<p align="center"><b>Figure 8:</b> 学习率预热对解决训练不稳定性的有益影响</p>

<ul>
<li>在上面的内容中，我们假设从业者已经确定了让模型变得不稳定的学习率。也就是 <code>unstable_base_learning_rate</code>。</li>
<li>预热的过程涉及了预先安排一个学习率计划，这个计划会将学习率从0提升到某个稳定的 <code>base_learning_rate</code>，这至少比 <code>unstable_base_learning_rate</code>要大一个数量级。<br>默认设置是尝试使用 <code>unstable_base_learning_rate</code> 10倍大小的 <code>base_learning_rate</code>。值得注意的是，对于使用例如100倍<br><code>unstable_base_learning_rate</code>这样的数值，那么可能需要重新运行整个过程。具体安排如下：<ul>
<li>在<code>warmup_steps</code>的过程中，将数值从0提升到 <code>base_learning_rate</code>。</li>
<li><code>post_warmup_steps</code>的过程中，以一个恒定的速率进行训练。</li>
</ul>
</li>
<li>我们的目标是找到最少的 <code>warmup_steps</code>，以此来让我们获得远高于<code>unstable_base_learning_rate</code>的峰值学习率。</li>
<li>因此，对于，每个 <code>base_learning_rate</code>来说， 我们需要对 <code>warmup_steps</code> 以及<code>post_warmup_steps</code>进行调优。 通常将 <code>post_warmup_steps</code> 设定为<code>warmup_steps</code>的两倍就可以了。</li>
<li>预热可以独立于现有的衰减计划进行调整。<br><code>warmup_steps</code> 应该以几个不同的数量级进行扫描。例如，在样本学习中可以以[10, 10<sup>3</sup>, 10<sup>4</sup>,10<sup>5</sup>]这样的数量级进行尝试。最大的搜索值不应超过<code>max_train_steps</code>的10%。</li>
<li>一旦建立了不会破坏以 <code>base_learning_rate</code> 进行训练的<code>warmup_steps</code>，就应该将其应用于Baseline模型。<br>本质上，我们将这个安排添加到现有安排上，并使用上面讨论中选择的最佳检查点来将这个实验与Baseline进行比较。例如，如果我们一开始的<code>max_train_steps</code>的值是10000，<br>并进行了1000次<code>warmup_steps</code>。那么，新的训练过程总共应当进行了11000次。</li>
<li>如果稳定训练需要较长的<code>warmup_steps</code>（大于<code>max_train_steps</code>的5%），则可能需要增加<code>max_train_steps</code>来解决这个问题。</li>
<li>在整个工作量的范围中并不存在真正意义上的<code>标准</code>值。有些模型可能只需要100次训练，然而有些模型则可能需要4万次以上的训练，尤其是Transformer类。</li>
</ul>
<h4 id="梯度截断"><a href="#梯度截断" class="headerlink" title="梯度截断"></a>梯度截断</h4><p align="center">
<img src="/img/tuning_playbook-gradient_clipping.png" width="80%" alt="Gradient clipping on early training instabilities">
</p>

<p align="center"><b>Figure 9:</b> 梯度截断纠正早期训练不稳定性的图示。</p>

<ul>
<li>当出现较大或离群的梯度问题时，梯度截断会变得非常有用。</li>
<li>梯度截断可以修复早期训练中出现的不稳定性（早期较大的梯度范数），或中期训练中出现的不稳定性（训练中期突然出现的梯度尖峰）。</li>
<li>有时，较长的预热时间可以纠正梯度截断无法纠正的不稳定性: 请查看<a href="#如何对学习率进行预热">之前的章节</a>。<ul>
<li>🤖 在预热的时候，进行梯度截断会发生什么？</li>
</ul>
</li>
<li>理想的截断阈值要刚好高于“典型的”梯度范数。</li>
<li>下面是一个关于如何进行梯度截断的案例：<ul>
<li>如果梯度范数 $\left | g \right |$ 大于梯度截断的阈值 $\lambda$，那么就需要进行 ${g}’= \lambda \times \frac{g}{\left | g \right |}$。此处的 ${g}’$是新的梯度。</li>
</ul>
</li>
<li>在训练期间记录下未截断梯度范数。 默认情况下会生成:<ul>
<li>梯度范数与步骤数量的关系图</li>
<li>聚合所有步数的梯度范数直方图</li>
</ul>
</li>
<li>根据梯度范数的第90百分位数选择梯度截断阈值。<ul>
<li>这个阈值的大小与工作量有关。但90%是一个很好的选择。但如果这个奏效，那么可以对其进行调优。</li>
<li>🤖 那么，某种适应性策略会怎么样呢?</li>
</ul>
</li>
<li>如果我们尝试梯度截断并且不稳定问题仍然存在，那么我们可以更努力地尝试（例如，阈值更小）。</li>
<li>极端激进的梯度截断本质上是一种降低学习率的奇怪方式。 如果我们发现自己使用了非常激进的截断，那么我们可能应该只降低学习率。</li>
<li>我们通常会认为以某种方式将超过 50% 的更新剪裁为“极其激进”。</li>
<li>如果我们需要进行极其激进的梯度截断来处理我们的不稳定问题，那么我们不妨降低学习率。</li>
</ul>
<p>&lt;/details&gt;</p>
<h3 id="为什么将学习率和其他优化参数称为超参数？-它们不是任何先验分布的参数。"><a href="#为什么将学习率和其他优化参数称为超参数？-它们不是任何先验分布的参数。" class="headerlink" title="为什么将学习率和其他优化参数称为超参数？ 它们不是任何先验分布的参数。"></a>为什么将学习率和其他优化参数称为超参数？ 它们不是任何先验分布的参数。</h3><ul>
<li>确实，在贝叶斯机器学习中，“超参数”这一术语拥有一种更加精确的<a target="_blank" rel="noopener" href="https://en.wikipedia.org/wiki/Hyperparameter">含义</a>，我们在深度学习中调优的学习率和大部分其他被叫做“超参数”的参数都是对术语的一种滥用。</li>
<li>我们更愿意使用“元参数”这个术语来表示学习率、架构参数以及我们在深度学习中调整的所有其他参数， 因为它避免了因滥用“超参数”一词而引起的潜在混淆（例如，可能在讨论贝叶斯优化时，概率响应曲面模型拥有它自己的真实超参数，此时使用超参数一词是不合适的。）</li>
<li>不幸的是，尽管可能会造成混淆，但超参数这个术语在深度学习社区中已经变得极为通俗。</li>
<li>因此，对于一份文档而言，例如本文。为了面向普通大众，我们决定为该领域的一个混乱来源做出贡献，希望避免产生另一个混淆。</li>
<li>也就是说，在发布一篇研究论文的时候，我们可能采取了一种不同的说法。并且，在大多数情况下，我们推荐其他人使用“元参数”这个说法。</li>
</ul>
<h3 id="为什么不应该调整Batch-Size来直接提高验证集性能"><a href="#为什么不应该调整Batch-Size来直接提高验证集性能" class="headerlink" title="为什么不应该调整Batch Size来直接提高验证集性能?"></a>为什么不应该调整Batch Size来直接提高验证集性能?</h3><ul>
<li><em>在不更改训练工作流其他细节的情况下</em>， 修改batch size 通常会影响验证集的性能。</li>
<li>但是，如果针对每个batch size单独调优，则两个batch size之间的验证集性能差异通常会消失。</li>
<li>受batch size影响最强烈的那些超参数，即优化器超参数（例如：学习率、动量）和正则化超参数，这些东西对于每个batch size进行单独调优的时候是最重要的。<ul>
<li>由于样本方差的原因，较小的batch size会在训练算法中引入更多的不确定性，并且这些不确定性可能存在着正则化效果。因此，较大的batch size可能更容易过度拟合。并且，这可能需要更强的正则化和/或额外的正则化技术。</li>
</ul>
</li>
<li>此外， 当修改batch size的大小时，<a href="#choosing-the-batch-size-to-minimize-training-time">训练步骤的数量可能也需要进行调整</a>。</li>
<li>一旦考虑了所有这些因素带来的影响，目前还没有任何能够令人信服的证据表明batch size会影响最大可实现的验证性能（具体请阅读 <a target="_blank" rel="noopener" href="https://arxiv.org/abs/1811.03600">Shallue et al. 2018</a>）。</li>
</ul>
<h3 id="所有流行的优化算法的更新规则是什么？"><a href="#所有流行的优化算法的更新规则是什么？" class="headerlink" title="所有流行的优化算法的更新规则是什么？"></a>所有流行的优化算法的更新规则是什么？</h3><h4 id="Stochastic-gradient-descent-SGD"><a href="#Stochastic-gradient-descent-SGD" class="headerlink" title="Stochastic gradient descent (SGD)"></a>Stochastic gradient descent (SGD)</h4><script type="math/tex; mode=display">\theta_{t+1} = \theta_{t} - \eta_t \nabla \mathcal{l}(\theta_t)</script><h4 id="Momentum"><a href="#Momentum" class="headerlink" title="Momentum"></a>Momentum</h4><script type="math/tex; mode=display">v_0 = 0</script><script type="math/tex; mode=display">v_{t+1} = \gamma v_{t} + \nabla \mathcal{l}(\theta_t)</script><script type="math/tex; mode=display">\theta_{t+1} = \theta_{t} - \eta_t v_{t+1}</script><h4 id="Nesterov"><a href="#Nesterov" class="headerlink" title="Nesterov"></a>Nesterov</h4><script type="math/tex; mode=display">v_0 = 0</script><script type="math/tex; mode=display">v_{t+1} = \gamma v_{t} + \nabla \mathcal{l}(\theta_t)</script><script type="math/tex; mode=display">\theta_{t+1} = \theta_{t} - \eta_t( \gamma v_{t+1} + \nabla \mathcal{l}(\theta_{t})</script><h4 id="RMSProp"><a href="#RMSProp" class="headerlink" title="RMSProp"></a>RMSProp</h4><script type="math/tex; mode=display">v_0 = 1 \text{,} m_0 = 0</script><script type="math/tex; mode=display">v_{t+1} = \rho v_{t} + (1 - \rho) \nabla \mathcal{l}(\theta_t)^2</script><script type="math/tex; mode=display">m_{t+1} = \gamma m_{t} + \frac{\eta_t}{\sqrt{v_{t+1} + \epsilon}}\nabla \mathcal{l}(\theta_t)</script><script type="math/tex; mode=display">\theta_{t+1} = \theta_{t} - m_{t+1}</script><h4 id="ADAM"><a href="#ADAM" class="headerlink" title="ADAM"></a>ADAM</h4><script type="math/tex; mode=display">m_0 = 0 \text{,} v_0 = 0</script><script type="math/tex; mode=display">m_{t+1} = \beta_1 m_{t} + (1 - \beta_1) \nabla \mathcal{l} (\theta_t)</script><script type="math/tex; mode=display">v_{t+1} = \beta_2 v_{t} + (1 - \beta_2) \nabla \mathcal{l}(\theta_t)^2</script><script type="math/tex; mode=display">b_{t+1} = \frac{\sqrt{1 - \beta_2^{t+1}}}{1 - \beta_1^{t+1}}</script><script type="math/tex; mode=display">\theta_{t+1} = \theta_{t} - \alpha_t \frac{m_{t+1}}{\sqrt{v_{t+1}} + \epsilon} b_{t+1}</script><h4 id="NADAM"><a href="#NADAM" class="headerlink" title="NADAM"></a>NADAM</h4><script type="math/tex; mode=display">m_0 = 0 \text{,} v_0 = 0</script><script type="math/tex; mode=display">m_{t+1} = \beta_1 m_{t} + (1 - \beta_1) \nabla \mathcal{l} (\theta_t)</script><script type="math/tex; mode=display">v_{t+1} = \beta_2 v_{t} + (1 - \beta_2) \nabla \mathcal{l} (\theta_t)^2</script><script type="math/tex; mode=display">b_{t+1} = \frac{\sqrt{1 - \beta_2^{t+1}}}{1 - \beta_1^{t+1}}</script><script type="math/tex; mode=display">\theta_{t+1} = \theta_{t} - \alpha_t \frac{\beta_1 m_{t+1} + (1 - \beta_1) \nabla \mathcal{l} (\theta_t)}{\sqrt{v_{t+1}} + \epsilon} b_{t+1}</script><h2 id="致谢"><a href="#致谢" class="headerlink" title="致谢"></a>致谢</h2><ul>
<li>我们要感谢Max Bileschi, Roy Frostig, Zelda Mariet, Stan<br>Bileschi, Mohammad Norouzi, Chris DuBois以及Charles Sutton 阅读本手稿并提出宝贵的意见来改进我们的内容。</li>
<li>我们复用了最初由Naman Agarwal为其他联合研究制作的几个分析图的一些实验数据。</li>
<li>我们要感谢Will Chen对文档演讲内容提出的宝贵建议。</li>
<li>我们还要感谢 Rohan Anil 与我们进行了有益的讨论。</li>
</ul>
<h2 id="引用"><a href="#引用" class="headerlink" title="引用"></a>引用</h2><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">@misc&#123;tuningplaybookgithub,</span><br><span class="line">  author = &#123;Varun Godbole and George E. Dahl and Justin Gilmer and Christopher J. Shallue and Zachary Nado&#125;,</span><br><span class="line">  title = &#123;Deep Learning Tuning Playbook&#125;,</span><br><span class="line">  url = &#123;http://github.com/google/tuning_playbook&#125;,</span><br><span class="line">  year = &#123;2023&#125;,</span><br><span class="line">  note = &#123;Version 1.0&#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<h2 id="关于贡献"><a href="#关于贡献" class="headerlink" title="关于贡献"></a>关于贡献</h2><ul>
<li><p>这并不是一款由谷歌官方所支持的产品。</p>
</li>
<li><p>我们欢迎听到来自您的反馈。</p>
<ul>
<li>如果你喜欢这本手册, 请给我们 <a target="_blank" rel="noopener" href="https://docs.github.com/en/get-started/exploring-projects-on-github/saving-repositories-with-stars#starring-a-repository">留一颗小星星</a>！或者，可以给我们的邮箱<br>deep-learning-tuning-playbook [at] googlegroups.com发送邮件。 这些推荐有帮于证明我们创建更多这样的内容是合理的。</li>
<li>如果有任何不正确的地方，欢迎在GitHub的讨论区提出相关问题。对于不适合问题的问题或其他消息，请在 GitHub 上打开一个新的讨论主题。</li>
</ul>
</li>
<li><p>正如在序言中所讨论的，这是一份在线文档。我们会定期进行大大小小的修改。如果你想获取相关通知，请关注我们的仓库 (具体配置请查看 <a target="_blank" rel="noopener" href="https://docs.github.com/en/account-and-profile/managing-subscriptions-and-notifications-on-github/setting-up-notifications/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository">操作指南</a>).</p>
</li>
<li><p>请不要在未通过问题跟踪系统与作者协调的情况下提交pull request。</p>
</li>
</ul>
<h3 id="贡献者许可协议"><a href="#贡献者许可协议" class="headerlink" title="贡献者许可协议"></a>贡献者许可协议</h3><p>对该项目的贡献必须附有贡献者许可协议 (CLA)。 对于你（或你的雇主）所贡献的内容将保留其相关版权； 这只是允许我们使用和重新分配您的贡献作为项目的一部分。 请前往 <a target="_blank" rel="noopener" href="https://cla.developers.google.com/">https://cla.developers.google.com/</a> 查看您当前存档的协议或签署新协议。</p>
<p>通常，您只需要签署一次CLA协议即可。因此，如果您已经签署过一次（即使针对的是其他项目），那么您可能无需再次签署。</p>
<h3 id="代码审核"><a href="#代码审核" class="headerlink" title="代码审核"></a>代码审核</h3><p>所有的提交（包括来自项目成员的提交）都需要进行审核。出于这个目的，我们会使用Github提供的pull request功能来进行代码审核。 关于如何使用pull request，请查看<br><a target="_blank" rel="noopener" href="https://help.github.com/articles/about-pull-requests/">GitHub Help</a> 获取更多信息.</p>
<h3 id="社区指南"><a href="#社区指南" class="headerlink" title="社区指南"></a>社区指南</h3><p>本项目遵循<br><a target="_blank" rel="noopener" href="https://opensource.google/conduct/">谷歌开源社区指南</a>.</p>
</article><div class="post-copyright"><div class="post-copyright__author"><span class="post-copyright-meta">文章作者: </span><span class="post-copyright-info"><a href="https://kilogrand.gitee.io">kiloGrand</a></span></div><div class="post-copyright__type"><span class="post-copyright-meta">文章链接: </span><span class="post-copyright-info"><a href="https://kilogrand.gitee.io/2023/02/26/tuning_playbook-zh_cn/">https://kilogrand.gitee.io/2023/02/26/tuning_playbook-zh_cn/</a></span></div><div class="post-copyright__notice"><span class="post-copyright-meta">版权声明: </span><span class="post-copyright-info">本博客所有文章除特别声明外，均采用 <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/" target="_blank">CC BY-NC-SA 4.0</a> 许可协议。转载请注明来自 <a href="https://kilogrand.gitee.io" target="_blank">kiloGrand</a>！</span></div></div><div class="tag_share"><div class="post-meta__tag-list"></div><div class="post_share"></div></div><nav class="pagination-post" id="pagination"><div class="prev-post pull-left"><a href="/2022/10/03/nlp-sentiment-analysis-bert-atsc/"><img class="prev-cover" src="/img/coding.jpg" onerror="onerror=null;src='/img/404.jpg'" alt="cover of previous post"><div class="pagination-info"><div class="label">上一篇</div><div class="prev_info">BERT在情感分析ATSC子任务的应用</div></div></a></div><div class="next-post pull-right"><a href="/2023/03/13/kuiper_infer-L2/"><img class="next-cover" src="/img/coding.jpg" onerror="onerror=null;src='/img/404.jpg'" alt="cover of next post"><div class="pagination-info"><div class="label">下一篇</div><div class="next_info">自制深度学习框架--张量</div></div></a></div></nav></div><div class="aside-content" id="aside-content"><div class="card-widget card-info"><div class="is-center"><div class="avatar-img"><img src="/img/profile.png" onerror="this.onerror=null;this.src='/img/friend_404.gif'" alt="avatar"/></div><div class="author-info__name">kiloGrand</div><div class="author-info__description">coder && data-science researcher</div></div><div class="card-info-data site-data is-center"><a href="/archives/"><div class="headline">文章</div><div class="length-num">46</div></a><a href="/tags/"><div class="headline">标签</div><div class="length-num">6</div></a><a href="/categories/"><div class="headline">分类</div><div class="length-num">5</div></a></div><a id="card-info-btn" target="_blank" rel="noopener" href="https://github.com/kiloGrand/"><i class="fab fa-github"></i><span>Follow Me</span></a></div><div class="card-widget card-announcement"><div class="item-headline"><i class="fas fa-bullhorn fa-shake"></i><span>公告</span></div><div class="announcement_content">This is my Blog</div></div><div class="sticky_layout"><div class="card-widget" id="card-toc"><div class="item-headline"><i class="fas fa-stream"></i><span>目录</span><span class="toc-percentage"></span></div><div class="toc-content"><ol class="toc"><li class="toc-item toc-level-1"><a class="toc-link" href="#%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E8%B0%83%E4%BC%98%E6%8C%87%E5%8D%97%E4%B8%AD%E6%96%87%E7%89%88"><span class="toc-number">1.</span> <span class="toc-text">深度学习调优指南中文版</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#%E7%9B%AE%E5%BD%95"><span class="toc-number">1.1.</span> <span class="toc-text">目录</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E8%BF%99%E4%BB%BD%E6%89%8B%E5%86%8C%E6%98%AF%E4%B8%BA%E8%B0%81%E5%87%86%E5%A4%87%E7%9A%84%EF%BC%9F"><span class="toc-number">1.2.</span> <span class="toc-text">这份手册是为谁准备的？</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E4%B8%BA%E4%BB%80%E4%B9%88%E9%9C%80%E8%A6%81%E8%BF%99%E4%BB%BD%E8%B0%83%E4%BC%98%E6%89%8B%E5%86%8C%EF%BC%9F"><span class="toc-number">1.3.</span> <span class="toc-text">为什么需要这份调优手册？</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E5%BC%80%E5%A7%8B%E6%96%B0%E9%A1%B9%E7%9B%AE%E7%9A%84%E6%8C%87%E5%8D%97"><span class="toc-number">1.4.</span> <span class="toc-text">开始新项目的指南</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#%E9%80%89%E6%8B%A9%E6%A8%A1%E5%9E%8B%E6%9E%B6%E6%9E%84"><span class="toc-number">1.4.1.</span> <span class="toc-text">选择模型架构</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E9%80%89%E6%8B%A9%E4%BC%98%E5%8C%96%E5%99%A8"><span class="toc-number">1.4.2.</span> <span class="toc-text">选择优化器</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E9%80%89%E6%8B%A9BatchSize"><span class="toc-number">1.4.3.</span> <span class="toc-text">选择BatchSize</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#%E7%A1%AE%E5%AE%9A%E5%8F%AF%E8%A1%8C%E7%9A%84Batch-Size%E5%B9%B6%E4%BC%B0%E8%AE%A1%E8%AE%AD%E7%BB%83%E5%90%9E%E5%90%90%E9%87%8F"><span class="toc-number">1.4.3.1.</span> <span class="toc-text">确定可行的Batch Size并估计训练吞吐量</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E9%80%89%E6%8B%A9%E5%90%88%E9%80%82%E7%9A%84Batch-Size%E4%BB%A5%E6%9C%80%E5%B0%8F%E5%8C%96%E8%AE%AD%E7%BB%83%E6%97%B6%E9%97%B4"><span class="toc-number">1.4.3.2.</span> <span class="toc-text">选择合适的Batch Size以最小化训练时间</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E9%80%89%E6%8B%A9%E5%90%88%E9%80%82%E7%9A%84Batch-Size%E4%BB%A5%E6%9C%80%E5%B0%8F%E5%8C%96%E8%B5%84%E6%BA%90%E6%B6%88%E8%80%97"><span class="toc-number">1.4.3.3.</span> <span class="toc-text">选择合适的Batch Size以最小化资源消耗</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E6%9B%B4%E6%94%B9Batch-Size%E9%9C%80%E8%A6%81%E9%87%8D%E6%96%B0%E8%B0%83%E6%95%B4%E5%A4%A7%E5%A4%9A%E6%95%B0%E8%B6%85%E5%8F%82%E6%95%B0"><span class="toc-number">1.4.3.4.</span> <span class="toc-text">更改Batch Size需要重新调整大多数超参数</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#Batch-Norm%E4%BC%9A%E5%AF%B9Batch-Size%E7%9A%84%E9%80%89%E6%8B%A9%E9%80%A0%E6%88%90%E4%BB%80%E4%B9%88%E5%BD%B1%E5%93%8D%EF%BC%9F"><span class="toc-number">1.4.3.5.</span> <span class="toc-text">Batch Norm会对Batch Size的选择造成什么影响？</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E9%80%89%E6%8B%A9%E5%88%9D%E5%A7%8B%E9%85%8D%E7%BD%AE"><span class="toc-number">1.4.3.6.</span> <span class="toc-text">选择初始配置</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E6%8F%90%E9%AB%98%E6%A8%A1%E5%9E%8B%E6%80%A7%E8%83%BD%E7%9A%84%E7%A7%91%E5%AD%A6%E6%96%B9%E6%B3%95"><span class="toc-number">1.5.</span> <span class="toc-text">提高模型性能的科学方法</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#%E5%A2%9E%E9%87%8F%E8%B0%83%E6%95%B4%E7%AD%96%E7%95%A5"><span class="toc-number">1.5.1.</span> <span class="toc-text">增量调整策略</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E6%8E%A2%E7%B4%A2%E4%B8%8E%E5%88%A9%E7%94%A8"><span class="toc-number">1.5.2.</span> <span class="toc-text">探索与利用</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E9%80%89%E6%8B%A9%E4%B8%8B%E4%B8%80%E8%BD%AE%E5%AE%9E%E9%AA%8C%E7%9A%84%E7%9B%AE%E6%A0%87"><span class="toc-number">1.5.3.</span> <span class="toc-text">选择下一轮实验的目标</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E8%AE%BE%E8%AE%A1%E4%B8%8B%E4%B8%80%E8%BD%AE%E5%AE%9E%E9%AA%8C"><span class="toc-number">1.5.4.</span> <span class="toc-text">设计下一轮实验</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#%E8%AF%86%E5%88%AB%E7%9B%AE%E6%A0%87%E8%B6%85%E5%8F%82%E6%95%B0%E3%80%81%E5%86%97%E4%BD%99%E8%B6%85%E5%8F%82%E6%95%B0%E5%92%8C%E5%9B%BA%E5%AE%9A%E8%B6%85%E5%8F%82%E6%95%B0"><span class="toc-number">1.5.4.1.</span> <span class="toc-text">识别目标超参数、冗余超参数和固定超参数</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E5%88%9B%E5%BB%BA%E4%B8%80%E7%BB%84%E7%A0%94%E7%A9%B6"><span class="toc-number">1.5.4.2.</span> <span class="toc-text">创建一组研究</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E5%B9%B3%E8%A1%A1%E5%AE%9E%E9%AA%8C%E7%9A%84%E4%BF%A1%E6%81%AF%E9%87%8F%E5%92%8C%E6%88%90%E6%9C%AC"><span class="toc-number">1.5.4.3.</span> <span class="toc-text">平衡实验的信息量和成本</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E4%BB%8E%E5%AE%9E%E9%AA%8C%E7%BB%93%E6%9E%9C%E4%B8%AD%E8%8E%B7%E5%8F%96%E7%BB%8F%E9%AA%8C"><span class="toc-number">1.5.5.</span> <span class="toc-text">从实验结果中获取经验</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#%E8%AF%86%E5%88%AB%E9%94%99%E8%AF%AF%E7%9A%84%E6%90%9C%E7%B4%A2%E7%A9%BA%E9%97%B4%E8%BE%B9%E7%95%8C"><span class="toc-number">1.5.5.1.</span> <span class="toc-text">识别错误的搜索空间边界</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E6%B2%A1%E6%9C%89%E5%9C%A8%E6%90%9C%E7%B4%A2%E7%A9%BA%E9%97%B4%E4%B8%AD%E9%87%87%E6%A0%B7%E8%B6%B3%E5%A4%9F%E7%9A%84%E7%82%B9"><span class="toc-number">1.5.5.2.</span> <span class="toc-text">没有在搜索空间中采样足够的点</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E6%A3%80%E6%9F%A5%E8%AE%AD%E7%BB%83%E6%9B%B2%E7%BA%BF"><span class="toc-number">1.5.5.3.</span> <span class="toc-text">检查训练曲线</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E4%BD%BF%E7%94%A8isolation%E5%9B%BE%E6%A3%80%E6%B5%8B%E6%9B%B4%E6%94%B9%E6%98%AF%E5%90%A6%E6%9C%89%E7%94%A8"><span class="toc-number">1.5.5.4.</span> <span class="toc-text">使用isolation图检测更改是否有用</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E8%87%AA%E5%8A%A8%E5%8C%96%E5%B8%B8%E7%94%A8%E7%9A%84%E7%BB%98%E5%9B%BE"><span class="toc-number">1.5.5.5.</span> <span class="toc-text">自动化常用的绘图</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E7%A1%AE%E5%AE%9A%E6%98%AF%E5%90%A6%E9%87%87%E7%94%A8%E6%AD%A4%E8%AE%AD%E7%BB%83%E5%B7%A5%E4%BD%9C%E6%B5%81%E6%9B%B4%E6%94%B9%E6%88%96%E8%B6%85%E5%8F%82%E6%95%B0%E9%85%8D%E7%BD%AE"><span class="toc-number">1.5.6.</span> <span class="toc-text">确定是否采用此训练工作流更改或超参数配置</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E6%8E%A2%E7%B4%A2%E7%BB%93%E6%9D%9F%E5%90%8E"><span class="toc-number">1.5.7.</span> <span class="toc-text">探索结束后</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E7%A1%AE%E5%AE%9A%E6%AF%8F%E6%AC%A1%E8%AE%AD%E7%BB%83%E8%BF%90%E8%A1%8C%E7%9A%84%E6%AD%A5%E6%95%B0"><span class="toc-number">1.6.</span> <span class="toc-text">确定每次训练运行的步数</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#%E5%BD%93%E8%AE%AD%E7%BB%83%E4%B8%8D%E5%8F%97%E8%AE%A1%E7%AE%97%E9%99%90%E5%88%B6%E6%97%B6%E5%A6%82%E4%BD%95%E5%86%B3%E5%AE%9A%E8%AF%A5%E8%AE%AD%E7%BB%83%E5%A4%9A%E4%B9%85"><span class="toc-number">1.6.1.</span> <span class="toc-text">当训练不受计算限制时如何决定该训练多久</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#%E4%BD%BF%E7%94%A8%E5%AD%A6%E4%B9%A0%E7%8E%87%E6%90%9C%E7%B4%A2%E7%AE%97%E6%B3%95%E6%9D%A5%E7%A1%AE%E5%AE%9A-max-train-steps-%E7%9A%84%E5%88%9D%E5%A7%8B%E5%80%BC"><span class="toc-number">1.6.1.1.</span> <span class="toc-text">使用学习率搜索算法来确定 max_train_steps 的初始值</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E5%BD%93%E8%AE%AD%E7%BB%83%E5%8F%97%E8%AE%A1%E7%AE%97%E9%99%90%E5%88%B6%E6%97%B6%E5%A6%82%E4%BD%95%E5%86%B3%E5%AE%9A%E8%AF%A5%E8%AE%AD%E7%BB%83%E5%A4%9A%E4%B9%85"><span class="toc-number">1.6.2.</span> <span class="toc-text">当训练受计算限制时如何决定该训练多久</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#%E7%AC%AC%E4%B8%80%E8%BD%AE"><span class="toc-number">1.6.2.1.</span> <span class="toc-text">第一轮</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E7%AC%AC%E4%BA%8C%E8%BD%AE"><span class="toc-number">1.6.2.2.</span> <span class="toc-text">第二轮</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E5%85%B3%E4%BA%8E%E8%AE%AD%E7%BB%83%E7%AE%A1%E9%81%93%E7%9A%84%E9%A2%9D%E5%A4%96%E8%A1%A5%E5%85%85"><span class="toc-number">1.7.</span> <span class="toc-text">关于训练管道的额外补充</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#%E4%BC%98%E5%8C%96%E8%BE%93%E5%85%A5%E7%AE%A1%E9%81%93"><span class="toc-number">1.7.1.</span> <span class="toc-text">优化输入管道</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E8%AF%84%E4%BC%B0%E6%A8%A1%E5%9E%8B%E6%80%A7%E8%83%BD"><span class="toc-number">1.7.2.</span> <span class="toc-text">评估模型性能</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#%E8%AF%84%E4%BC%B0%E8%AE%BE%E7%BD%AE"><span class="toc-number">1.7.2.1.</span> <span class="toc-text">评估设置</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E8%AE%BE%E7%BD%AE%E5%AE%9A%E6%9C%9F%E8%AF%84%E4%BC%B0"><span class="toc-number">1.7.2.2.</span> <span class="toc-text">设置定期评估</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E9%80%89%E6%8B%A9%E6%A0%B7%E6%9C%AC%E8%BF%9B%E8%A1%8C%E5%AE%9A%E6%9C%9F%E8%AF%84%E4%BC%B0"><span class="toc-number">1.7.2.3.</span> <span class="toc-text">选择样本进行定期评估</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E4%BF%9D%E5%AD%98%E6%A3%80%E6%9F%A5%E7%82%B9%E5%B9%B6%E8%BF%BD%E6%BA%AF%E9%80%89%E6%8B%A9%E6%9C%80%E4%BD%B3%E6%A3%80%E6%9F%A5%E7%82%B9"><span class="toc-number">1.7.3.</span> <span class="toc-text">保存检查点并追溯选择最佳检查点</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E8%AE%BE%E7%BD%AE%E5%AE%9E%E9%AA%8C%E8%B7%9F%E8%B8%AA"><span class="toc-number">1.7.4.</span> <span class="toc-text">设置实验跟踪</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#BatchNorm%E7%9A%84%E5%AE%9E%E7%8E%B0%E7%BB%86%E8%8A%82"><span class="toc-number">1.7.5.</span> <span class="toc-text">BatchNorm的实现细节</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E5%A4%9A%E4%B8%BB%E6%9C%BA%E7%AE%A1%E9%81%93%E7%9A%84%E8%80%83%E8%99%91%E5%9B%A0%E7%B4%A0"><span class="toc-number">1.7.6.</span> <span class="toc-text">多主机管道的考虑因素</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98%E7%9A%84%E5%9B%9E%E7%AD%94"><span class="toc-number">1.8.</span> <span class="toc-text">常见问题的回答</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#%E6%9C%80%E5%A5%BD%E7%9A%84%E5%AD%A6%E4%B9%A0%E7%8E%87%E8%A1%B0%E5%87%8F%E6%96%B9%E6%A1%88%E6%98%AF%E4%BB%80%E4%B9%88"><span class="toc-number">1.8.1.</span> <span class="toc-text">最好的学习率衰减方案是什么</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E6%88%91%E5%BA%94%E8%AF%A5%E4%BD%BF%E7%94%A8%E5%93%AA%E7%A7%8D%E5%AD%A6%E4%B9%A0%E7%8E%87%E8%A1%B0%E5%87%8F%E6%96%B9%E6%A1%88%E4%BD%9C%E4%B8%BA%E9%BB%98%E8%AE%A4%E5%80%BC%EF%BC%9F"><span class="toc-number">1.8.2.</span> <span class="toc-text">我应该使用哪种学习率衰减方案作为默认值？</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E4%B8%BA%E4%BB%80%E4%B9%88%E6%9C%89%E4%BA%9B%E8%AE%BA%E6%96%87%E6%9C%89%E5%A4%8D%E6%9D%82%E7%9A%84%E5%AD%A6%E4%B9%A0%E7%8E%87%E8%A1%B0%E5%87%8F%E6%96%B9%E6%A1%88%EF%BC%9F"><span class="toc-number">1.8.3.</span> <span class="toc-text">为什么有些论文有复杂的学习率衰减方案？</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#Adam-%E7%9A%84%E8%B6%85%E5%8F%82%E6%95%B0%E5%BA%94%E8%AF%A5%E5%A6%82%E4%BD%95%E8%B0%83%E6%95%B4%EF%BC%9F"><span class="toc-number">1.8.4.</span> <span class="toc-text">Adam 的超参数应该如何调整？</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E4%B8%BA%E4%BB%80%E4%B9%88%E5%9C%A8%E4%BC%98%E5%8C%96%E7%9A%84%E6%8E%A2%E7%B4%A2%E9%98%B6%E6%AE%B5%E4%BD%BF%E7%94%A8Quasi-Random-Search%E8%80%8C%E4%B8%8D%E6%98%AF%E6%9B%B4%E5%A4%8D%E6%9D%82%E7%9A%84%E9%BB%91%E7%9B%92%E4%BC%98%E5%8C%96%E7%AE%97%E6%B3%95%EF%BC%9F"><span class="toc-number">1.8.5.</span> <span class="toc-text">为什么在优化的探索阶段使用Quasi-Random-Search而不是更复杂的黑盒优化算法？</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E5%9C%A8%E5%93%AA%E9%87%8C%E5%8F%AF%E4%BB%A5%E6%89%BE%E5%88%B0Quasi-Random-Search%E7%9A%84%E5%AE%9E%E7%8E%B0%EF%BC%9F"><span class="toc-number">1.8.6.</span> <span class="toc-text">在哪里可以找到Quasi-Random-Search的实现？</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E9%9C%80%E8%A6%81%E5%A4%9A%E5%B0%91%E6%AC%A1%E8%AF%95%E9%AA%8C%E6%89%8D%E8%83%BD%E9%80%9A%E8%BF%87Quasi-Random-Search%E8%8E%B7%E5%BE%97%E8%BE%83%E5%A5%BD%E7%9A%84%E7%BB%93%E6%9E%9C%EF%BC%9F"><span class="toc-number">1.8.7.</span> <span class="toc-text">需要多少次试验才能通过Quasi-Random-Search获得较好的结果？</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#%E8%AF%86%E5%88%AB%E4%B8%8D%E7%A8%B3%E5%AE%9A%E7%9A%84%E8%AE%AD%E7%BB%83%E4%BB%BB%E5%8A%A1"><span class="toc-number">1.8.7.1.</span> <span class="toc-text">识别不稳定的训练任务</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E5%B8%B8%E8%A7%81%E4%B8%8D%E7%A8%B3%E5%AE%9A%E6%A8%A1%E5%BC%8F%E7%9A%84%E6%BD%9C%E5%9C%A8%E4%BF%AE%E5%A4%8D%E6%96%B9%E5%BC%8F"><span class="toc-number">1.8.7.2.</span> <span class="toc-text">常见不稳定模式的潜在修复方式</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E5%AD%A6%E4%B9%A0%E7%8E%87%E9%A2%84%E7%83%AD"><span class="toc-number">1.8.7.3.</span> <span class="toc-text">学习率预热</span></a><ol class="toc-child"><li class="toc-item toc-level-5"><a class="toc-link" href="#%E4%BD%95%E6%97%B6%E5%AF%B9%E5%AD%A6%E4%B9%A0%E7%8E%87%E8%BF%9B%E8%A1%8C%E9%A2%84%E7%83%AD"><span class="toc-number">1.8.7.3.1.</span> <span class="toc-text">何时对学习率进行预热</span></a></li><li class="toc-item toc-level-5"><a class="toc-link" href="#%E5%A6%82%E4%BD%95%E5%AF%B9%E5%AD%A6%E4%B9%A0%E7%8E%87%E8%BF%9B%E8%A1%8C%E9%A2%84%E7%83%AD"><span class="toc-number">1.8.7.3.2.</span> <span class="toc-text">如何对学习率进行预热</span></a></li></ol></li><li class="toc-item toc-level-4"><a class="toc-link" href="#%E6%A2%AF%E5%BA%A6%E6%88%AA%E6%96%AD"><span class="toc-number">1.8.7.4.</span> <span class="toc-text">梯度截断</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E4%B8%BA%E4%BB%80%E4%B9%88%E5%B0%86%E5%AD%A6%E4%B9%A0%E7%8E%87%E5%92%8C%E5%85%B6%E4%BB%96%E4%BC%98%E5%8C%96%E5%8F%82%E6%95%B0%E7%A7%B0%E4%B8%BA%E8%B6%85%E5%8F%82%E6%95%B0%EF%BC%9F-%E5%AE%83%E4%BB%AC%E4%B8%8D%E6%98%AF%E4%BB%BB%E4%BD%95%E5%85%88%E9%AA%8C%E5%88%86%E5%B8%83%E7%9A%84%E5%8F%82%E6%95%B0%E3%80%82"><span class="toc-number">1.8.8.</span> <span class="toc-text">为什么将学习率和其他优化参数称为超参数？ 它们不是任何先验分布的参数。</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E4%B8%BA%E4%BB%80%E4%B9%88%E4%B8%8D%E5%BA%94%E8%AF%A5%E8%B0%83%E6%95%B4Batch-Size%E6%9D%A5%E7%9B%B4%E6%8E%A5%E6%8F%90%E9%AB%98%E9%AA%8C%E8%AF%81%E9%9B%86%E6%80%A7%E8%83%BD"><span class="toc-number">1.8.9.</span> <span class="toc-text">为什么不应该调整Batch Size来直接提高验证集性能?</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E6%89%80%E6%9C%89%E6%B5%81%E8%A1%8C%E7%9A%84%E4%BC%98%E5%8C%96%E7%AE%97%E6%B3%95%E7%9A%84%E6%9B%B4%E6%96%B0%E8%A7%84%E5%88%99%E6%98%AF%E4%BB%80%E4%B9%88%EF%BC%9F"><span class="toc-number">1.8.10.</span> <span class="toc-text">所有流行的优化算法的更新规则是什么？</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#Stochastic-gradient-descent-SGD"><span class="toc-number">1.8.10.1.</span> <span class="toc-text">Stochastic gradient descent (SGD)</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#Momentum"><span class="toc-number">1.8.10.2.</span> <span class="toc-text">Momentum</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#Nesterov"><span class="toc-number">1.8.10.3.</span> <span class="toc-text">Nesterov</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#RMSProp"><span class="toc-number">1.8.10.4.</span> <span class="toc-text">RMSProp</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#ADAM"><span class="toc-number">1.8.10.5.</span> <span class="toc-text">ADAM</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#NADAM"><span class="toc-number">1.8.10.6.</span> <span class="toc-text">NADAM</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E8%87%B4%E8%B0%A2"><span class="toc-number">1.9.</span> <span class="toc-text">致谢</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E5%BC%95%E7%94%A8"><span class="toc-number">1.10.</span> <span class="toc-text">引用</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E5%85%B3%E4%BA%8E%E8%B4%A1%E7%8C%AE"><span class="toc-number">1.11.</span> <span class="toc-text">关于贡献</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#%E8%B4%A1%E7%8C%AE%E8%80%85%E8%AE%B8%E5%8F%AF%E5%8D%8F%E8%AE%AE"><span class="toc-number">1.11.1.</span> <span class="toc-text">贡献者许可协议</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E4%BB%A3%E7%A0%81%E5%AE%A1%E6%A0%B8"><span class="toc-number">1.11.2.</span> <span class="toc-text">代码审核</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E7%A4%BE%E5%8C%BA%E6%8C%87%E5%8D%97"><span class="toc-number">1.11.3.</span> <span class="toc-text">社区指南</span></a></li></ol></li></ol></li></ol></div></div><div class="card-widget card-recent-post"><div class="item-headline"><i class="fas fa-history"></i><span>最新文章</span></div><div class="aside-list"><div class="aside-list-item no-cover"><div class="content"><a class="title" href="/2023/03/24/kuiper_infer-L14/" title="自制深度学习框架--实现Yolov5的推理">自制深度学习框架--实现Yolov5的推理</a><time datetime="2023-03-24T12:00:00.000Z" title="发表于 2023-03-24 20:00:00">2023-03-24</time></div></div><div class="aside-list-item no-cover"><div class="content"><a class="title" href="/2023/03/23/kuiper_infer-L13/" title="自制深度学习框架--实现ResNet网络的推理">自制深度学习框架--实现ResNet网络的推理</a><time datetime="2023-03-23T12:00:00.000Z" title="发表于 2023-03-23 20:00:00">2023-03-23</time></div></div><div class="aside-list-item no-cover"><div class="content"><a class="title" href="/2023/03/22/kuiper_infer-L12/" title="自制深度学习框架--算子的执行流程">自制深度学习框架--算子的执行流程</a><time datetime="2023-03-22T12:00:00.000Z" title="发表于 2023-03-22 20:00:00">2023-03-22</time></div></div><div class="aside-list-item no-cover"><div class="content"><a class="title" href="/2023/03/21/kuiper_infer-L11/" title="自制深度学习框架--再探Tensor类并构建计算图的图关系">自制深度学习框架--再探Tensor类并构建计算图的图关系</a><time datetime="2023-03-21T12:00:00.000Z" title="发表于 2023-03-21 20:00:00">2023-03-21</time></div></div><div class="aside-list-item no-cover"><div class="content"><a class="title" href="/2023/03/20/kuiper_infer-L10/" title="自制深度学习框架--Im2Col原理与卷积层的实现">自制深度学习框架--Im2Col原理与卷积层的实现</a><time datetime="2023-03-20T12:00:00.000Z" title="发表于 2023-03-20 20:00:00">2023-03-20</time></div></div></div></div></div></div></main><footer id="footer"><div id="footer-wrap"><div class="copyright">&copy;2022 - 2023 By kiloGrand</div><div class="footer_custom_text">Hi, welcome to my blog!</div></div></footer></div><div id="rightside"><div id="rightside-config-hide"><button id="readmode" type="button" title="阅读模式"><i class="fas fa-book-open"></i></button><button id="darkmode" type="button" title="浅色和深色模式转换"><i class="fas fa-adjust"></i></button></div><div id="rightside-config-show"><button id="rightside_config" type="button" title="设置"><i class="fas fa-cog fa-spin"></i></button><button class="close" id="mobile-toc-button" type="button" title="目录"><i class="fas fa-list-ul"></i></button><button id="go-up" type="button" title="回到顶部"><i class="fas fa-arrow-up"></i></button></div></div><div id="local-search"><div class="search-dialog"><nav class="search-nav"><span class="search-dialog-title">搜索</span><span id="loading-status"></span><button class="search-close-button"><i class="fas fa-times"></i></button></nav><div class="is-center" id="loading-database"><i class="fas fa-spinner fa-pulse"></i><span>  数据库加载中</span></div><div class="search-wrap"><div id="local-search-input"><div class="local-search-box"><input class="local-search-box--input" placeholder="搜索文章" type="text"/></div></div><hr/><div id="local-search-results"></div></div></div><div id="search-mask"></div></div><div><script src="/js/utils.js"></script><script src="/js/main.js"></script><script src="https://cdn.jsdelivr.net/npm/@fancyapps/ui/dist/fancybox.umd.js"></script><script src="/js/search/local-search.js"></script><div class="js-pjax"><script>if (!window.MathJax) {
  window.MathJax = {
    tex: {
      inlineMath: [ ['$','$'], ["\\(","\\)"]],
      tags: 'ams'
    },
    chtml: {
      scale: 1.2
    },
    options: {
      renderActions: {
        findScript: [10, doc => {
          for (const node of document.querySelectorAll('script[type^="math/tex"]')) {
            const display = !!node.type.match(/; *mode=display/)
            const math = new doc.options.MathItem(node.textContent, doc.inputJax[0], display)
            const text = document.createTextNode('')
            node.parentNode.replaceChild(text, node)
            math.start = {node: text, delim: '', n: 0}
            math.end = {node: text, delim: '', n: 0}
            doc.math.push(math)
          }
        }, ''],
        insertScript: [200, () => {
          document.querySelectorAll('mjx-container:not\([display]\)').forEach(node => {
            const target = node.parentNode
            if (target.nodeName.toLowerCase() === 'li') {
              target.parentNode.classList.add('has-jax')
            } else {
              target.classList.add('has-jax')
            }
          });
        }, '', false]
      }
    }
  }
  
  const script = document.createElement('script')
  script.src = 'https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js'
  script.id = 'MathJax-script'
  script.async = true
  document.head.appendChild(script)
} else {
  MathJax.startup.document.state(0)
  MathJax.texReset()
  MathJax.typeset()
}</script></div><script async data-pjax src="//busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js"></script></div></body></html>